Python基础二（基础数据类型）

Posted 2021-01-26 Big_Dinosaur

基础数据类型

整数（int），字符串（str），布尔值（bool），列表（list），元祖（tuple），字典（dict），集合（set）。

数字int

#bit_length() 当十进制用二进制表示时，最少使用的位数
v = 11
data = v.bit_length()
print(data)

布尔值bool

真　　1　　True

假　　0　　False

i = bool(3)
print (i)   # True

i = bool(0)     # False
print (i)

i = int (True)
print (i)   # 1

i = int (False)
print (i)   # 0

if 1 :
    print (‘aaaa‘)  # aaaa

View Code

字符串str

字符串的索引和切片

索引即下标，就是字符串组成元素的第一个开始，初始索引以0开始，以此类推。

s = ‘alex wusir ritian qwertyuiopasdfgghjkl;zxcvbnm‘
s1 = s[0]
print (s1,type(s1))

s2 = s[2]
print (s2,type(s2))

s3 = s[-1]
print (s3)

s4 = s[-2]
print (s4)

# 切片：顾头不顾尾
s5 = s[0:4]
print (s5)

s6 = s[2:6]
print(s6)

s7 = s[5:]
print (s7)

s8 = s[0:]  # 默认到最后
print (s8)
s9 = s[:]
print (s9)

View Code

s = ‘alex wusir ritian qwertyuiopasdfgghjkl;zxcvbnm‘
# [起始索引：终止索引：步长]
s10 = s[0:3:2]
print (s10)     # ae
# 倒叙取
s11 = s[-1:-6:-2]
print (s11)     # mbc

s12 = s[3:0:-2]
print (s12)     # xl

s13 = s[2::-2]
print(s13)      # ea

View Code

字符串常用方法

字母大小写

#title()非字母隔开的部分，首字母大写，其他小写
s = ‘alex wuSir1taibai*ritian‘
print(s.title())
print (s.upper()) #全部大写
print (s.lower()) #全部小写

code = (‘dErF‘)
you_code = input(‘请输入你的验证码：‘)
if you_code.upper() == code.upper():
    print (‘输入正确‘)
else:
    print (‘输入错误‘)

验证码

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg=‘egon say hi‘
print(msg.title()) #每个单词的首字母大写

# 内同居中，总长度，空白处填充
ret2 = a1.center(20,"*")  
print(ret2)

#数字符串中的元素出现的个数。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)

a2 = "hqw	"
#	前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ret4 = a2.expandtabs()
print(ret4)

a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith(‘jdk‘,3,6)  # 顾头不顾腚
# print(ret4)  # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)

#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6)  # 返回的找到的元素的索引，如果找不到返回-1

# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。

#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# ret9 = ‘title,Tilte,atre,‘.split(‘t‘)
# print(ret9)
# ret91 = ‘title,Tilte,atre,‘.rsplit(‘t‘,1)
# print(ret91)

#format的三种玩法 格式化输出
res=‘{} {} {}‘.format(‘egon‘,18,‘male‘)
res=‘{1} {0} {1}‘.format(‘egon‘,18,‘male‘)
res=‘{name} {age} {sex}‘.format(sex=‘male‘,name=‘egon‘,age=18)

#strip
name=‘*egon**‘
print(name.strip(‘*‘)) 
print(name.lstrip(‘*‘))
print(name.rstrip(‘*‘))

#replace
name=‘alex say :i have one tesla,my name is alex‘
print(name.replace(‘alex‘,‘SB‘,1))

#####is系列
name=‘jinxin123‘
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成

View Code

join的一个用法

s = ‘alexwusir‘
s1 = ‘ ‘.join(s)
print (s1)     # a l e x w u s i r

View Code

加法计算器

# 实现一个整数加法计数器：如：
# count = input(‘请输入内容：‘） #如用户输入：5+9 或 5+ 9 或 5 + 9，然后进行分割再计算
方法1：
count = input (‘请输入内容：‘)
sum = 0
count = count.split(‘+‘)
for i in count:
    sum = sum + int(i)
print (sum)

方法2：
count = input(‘请输入内容：‘)
sum = 0
index = count.find(‘+‘)
l1 = count[0:index]
l2 = count[index+1:]
sum = int(l1) + int(l2)
print (sum)

View Code

计算用户输入的内容有几个整数

#计算用户输入的内容中有几个整数
#如：content = inpute(‘请输入内容：’），
count = input(‘请输入内容：‘)
sum = 0
for i in count:
    if i.isdigit():
        sum += 1
print (sum)

View Code

元祖stuple

元祖被称为只读列表，即数据可以被查询，但是不能被修改，所以，字符串的切片操作同样适用于元祖。

#元组
#tuple
tu = (1,2,‘wusir‘,‘taibai‘,[1,2,3],True)
l = [1,2,3,True]
for i in tu:
    print (i)
print (tu[2:])

#儿子不能更改，但是孙子有可能更改
tu1 = (1,2,‘wusir‘,[1,2,3],[2,3,4],‘taibai‘,True)
tu1[3].pop(1)
print (tu1)
tu1[3].append(‘taibai‘)
print (tu1)
print (len(tu1))
print (tu1.count(1))
print (l.count(1))
print (tu1.index(‘wusir‘))

#range  当作：范围列表[]，列表中的元素是数字，且可控的有效数字范围
#一般与for配合使用
for i in range(1,10):
    print (i)

for i in range(1,101):
    print (i)

for i in range(11):
    print (i)

for i in range(1,10,2):
    print (i)

for i in range(10,0,-1):
    print (i)

for i in range(10,-2,-1):
    print (i)
    
l1 = [1,2,3,‘alex‘,[2,3,‘wusir‘],7]
for i in l1:
    if type(i) == list:
        for j in i:
            print (j)
    else:
        print (i)

元祖的操作方法

列表list

列表是Python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组。

列表是有序的，有索引值，可切片，方便取值。

 增

li = [1,‘a‘,‘b‘,2,3,‘a‘]
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append(‘aaa‘) #增加到最后
# li.append([1,2,3]) #增加到最后
# print(li)
#
# li.extend([‘q,a,w‘]) #迭代的去增
# li.extend([‘q,a,w‘,‘aaa‘])
# li.extend(‘a‘)
# li.extend(‘abc‘)
# li.extend(‘a,b,c‘)
# print(li)

l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2]
while True:
    username = input(‘请输入你的名字：(q或Q退出)‘)
    if username.upper() == ‘Q‘:break
    l1.append(username)
    print (l1)

View Code

删

# 删除  pop
l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2]
l1.pop() #默认删除最后一个
print(l1)
ret = l1.pop(4)
print (ret)
print (l1)

# remove  按照元素去删
ret = l1.remove(‘alex‘)
print (l1)
print (ret)

# clear  清空列表
l1.clear()
print (l1)

# del  功能1：删除列表
del l1
print (l1)
# 功能2：可以按切片，按索引去删除
l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2]
del l1[0]
print (l1)
del l1[0:3]
print (l1)
del l1[1::2]
print (l1)

View Code

改

l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2]
# 按照索引去改
l1[0] = ‘男神‘
print (l1)  # [‘男神‘, True, ‘wusir‘, ‘ritian‘, ‘taibai‘, 3, 2]

# 按照切片去改
l1[0:2] = [‘屌丝‘,‘alex‘]
print (l1)  # [‘屌丝‘, ‘alex‘, ‘wusir‘, ‘ritian‘, ‘taibai‘, 3, 2]

l1[0:2] = [‘ 屌丝，alex‘]
print(l1)   # [‘ 屌丝，alex‘, ‘wusir‘, ‘ritian‘, ‘taibai‘, 3, 2]

View Code

查

# 按切片，按索引去查
l1 = [‘alex‘,True,‘wusir‘,‘ritian‘,‘taibai‘,3,2]
print (l1[0])
print (l1[0:3])

# for 循环查
for i in l1:
    print (i)

View Code

其它操作

# len 长度
l1 = [1,2,3,4,5,6,7,8]
print (len(l1))

# count 出现次数
print (l1.count(1))

# index 通过元素找索引
print (l1.index(1))

# sort 从小到大
l1 = [1,4,7,3,8,5,9,3]
# l1.sort()
# print (l1)

# sort(reverse) 从大到小
l1.sort(reverse=True)
print(l1)

# reverse 倒叙
l1.reverse()
print (l1)

View Code

 字典dict

字典是Python中唯一的映射类型，采用键值对（key-value）的形式存储数据。Python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变数据类型，如：数字、字符串、元祖

字典（dictionary）是除列表以外Python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

增

# dic[‘li‘] = ["a","b","c"]
# print(dic)
# setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
# dic.setdefault(‘k‘,‘v‘)
# print(dic)  # {‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘}
# dic.setdefault(‘k‘,‘v1‘)  # {‘age‘: 18, ‘name‘: ‘jin‘, ‘sex‘: ‘male‘, ‘k‘: ‘v‘}
# print(dic)

View Code

删

# dic_pop = dic.pop("a",‘无key默认返回值‘) # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
# print(dic_pop)
# del dic["name"]  # 没有返回值。
# print(dic)

# dic_pop1 = dic.popitem()  # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
# print(dic_pop1)  # (‘name‘,‘jin‘)

# dic_clear = dic.clear()  # 清空字典
# print(dic,dic_clear)  # {} None

View Code

改

# 改
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# dic2.update(dic)  # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
# print(dic2)

查

# value1 = dic["name"]  # 没有会报错
# print(value1)
#
# value2 = dic.get("djffdsafg","默认返回值")  # 没有可以返回设定的返回值
# print(value2)

View Code

其他操作

# item = dic.items()
# print(item,type(item))  # dict_items([(‘name‘, ‘jin‘), (‘sex‘, ‘male‘), (‘age‘, 18)]) <class ‘dict_items‘>
# 这个类型就是dict_items类型，可迭代的

# keys = dic.keys()
# print(keys,type(keys))  # dict_keys([‘sex‘, ‘age‘, ‘name‘]) <class ‘dict_keys‘>

# values = dic.values()
# print(values,type(values))  # dict_values([‘male‘, 18, ‘jin‘]) <class ‘dict_values‘> 同上

View Code

字典的循环

# dic = {"name":"jin","age":18,"sex":"male"}
# for key in dic:
#     print(key)
# for item in dic.items():
#     print(item)
# for key,value in dic.items():
#     print(key,value)

 集合

集合是无序的，不重复的数据集合，它里面的元素是可哈希的（不可变类型），但是集合本事是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

　　去重，把一个列表变成集合，就可以自动去重了。

　　关系测试，测试两组数据之间的交集、差集、并集等关系。

1. 集合的创建

set1 = set({1,2,‘barry‘})
set2 = {1,2,‘barry‘}
print(set1,set2)  # {1, 2, ‘barry‘} {1, 2, ‘barry‘}

2. 集合的增

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.add(‘景女神‘)
print(set1)

#update：迭代着增加
set1.update(‘A‘)
print(set1)
set1.update(‘老师‘)
print(set1)
set1.update([1,2,3])
print(set1)

3. 集合的删

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}

set1.remove(‘alex‘)  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

4. 集合的其他操作：

　　4.1 交集（& 或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　4.2 并集（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

　　4.3 差集（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

　　4.4 反交集 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　4.5 子集和超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

5. frozenset不可变集合，让集合变成不可变类型

s = frozenset(‘barry‘)
print(s,type(s))  # frozenset({‘a‘, ‘y‘, ‘b‘, ‘r‘}) <class ‘frozenset‘>

三、基础数据类型的总结

按存储空间的占用分（从低到高）

数字

字符串

集合：无序，即无序存索引相关信息

元祖：有序，需要存索引相关信息，不可变

列表：有序，需要存索引有关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射相关关系，可变，需要处理数据的增删改

按存值个数区分

标量/原子类型：数字，字符串

容器类型：列表，元祖，字典

按可变不可变区分：

可变：列表

不可变：数字，字符串，元祖，布尔值

按访问顺序区分

直接访问：数字

顺序访问（序列类型）：字符串，列表，元祖

key值访问（映射类型）：字典

四、其他（for，enumerate，range）

for循环：用户按照顺序循环可以迭代对象的内容

msg = ‘老男孩python是全国范围内最好的python培训机构‘
for item in msg:
    print(item)

li = [‘alex‘,‘银角‘,‘女神‘,‘egon‘,‘太白‘]
for i in li:
    print(i)

dic = {‘name‘:‘太白‘,‘age‘:18,‘sex‘:‘man‘}
for k,v in dic.items():
    print(k,v)

enumerate：枚举，对于一个可迭代的（iterable）、可遍历的对象（如列表，字符串）

enumerate将其组成一个索引序列，利用它可以同时获得索引和值

li = [‘alex‘,‘银角‘,‘女神‘,‘egon‘,‘太白‘]
for i in enumerate(li):
    print(i)
for index,name in enumerate(li,1):
    print(index,name)
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)　

 

range：指定范围，生成指定数字

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)