第二课 基础数据类型
一、基础数据类型：
1、整型 int
1.1 i=11 type(i)查看数据类型
1.2 重要方法：bit_length() 例子：i=11转成二进制0000 1011 那么i.bit_length() 值是4位，因此是查二进制所占的位数
1.3 查看 int 源码就能看到int所包含的全部方法
1.4 类型之前的转换：
int ---> str 添加单引号、双引号、三引号即可，比如：‘123’
int ---> bool 0表示假，非0表示真
str --->int 当字符串全部为数字时才能转换int类型，比如：a='132' b=int(a) print(type(a),type(b))
str --->bool print(bool(''))#空字符串，为假 ；print(bool(' ')) 非空为真
2、字符串str
2.1 字符串的索引与切片
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
# str 取数
# s='python自动化21期'
# s1=s[0]
# print(s1)
# s2=s[:6]
# print(s2)
# s3=s[6:7]
# print(s3)
# s4=s[:6:-1]
# print(s4)
# s5=s[:-1:2]#隔以为取一个数
# print(s5)
# print(s[:0:-2]) #反向设置步长
2.2 字符串的方法：
1、capitalize() 首字母变成大写，其他字母变成小写
2、upper() 全部转换成大写
3、lower() 全部转换成小写
例子：验证码不区分大小写：
code='AxBy'.upper() your_code=input('请输入验证码：').upper() if your_code == code: print('验证成功')
4、swapcase() 大小写反转
5、title()#*非字母的元素隔开的每个单词首字母大写
6、center(self, width, fillchar=None)居中，长度自己设定，默认填充物None 例子：s.center(30,"*")
7、startswith(self, prefix, start=None, end=None)是不是已什么开头，字符+开始位置+结束位置，也可不写
8、strip(self, chars=None)去除首尾的空格，制表符\t,换行符。不仅仅是去除空格....
8.1 lstrip(self, chars=None) 左侧截取
8.2 rsplit(self, sep=None, maxsplit=-1) 右侧截取
例1： # *** strip 去除首尾的空格，制表符\t,换行符。不仅仅是去除空格.... #lstrip() rstrip() # print(s) # s=' oldbay ' # s8 = s.strip() #去掉前后空格 # print(s8) # s='\toldbay\n' # s81 = s.strip('t') #去掉换行 # print(s81) # s='tyoldbayrrrte' # s81 = s.strip('tey')# 去掉前后包含tey的元素 # print(s81)
例子2：（以后用户登录都要加。strip(） name = input('用户名>>：').strip() if name=='oldbay': print('验证成功')
例子3：
while True:
cmd=input('>>: ').strip()
if len(cmd) == 0:continue #什么也不输入是跳过继续
cmd_l=cmd.split()
print('命令是:%s 命令的参数是:%s' %(cmd_l[0],cmd_l[1]))#第一个空格截图两个字符串输出
9、split(self, sep=None, maxsplit=-1)对字符串、列表进行分割转换及合并转换，可以将字符串转成列表，可以将列表转成字符
例子： # #*** split (str ---> list)字符串转成列表 # s = 'oldboy wusir alex' # l = s.split() # print(l) # s1 = 'oldboy,wusir,alex' # l = s1.split(',') # print(l) # l2 = s.split('o') #['', 'ldb', 'y wusir alex'] #当o是第一个字母时，以o截取，前面会生成一个空字符 # print(l2) # l2 = s.split('o',1) # ['', 'ldboywusiroalex'] #以第一个o截取 # print(l2) # s = 'oldBoy' # # join 将list --->str 将列表转成字符串（要求列表都是字符串）
# s9 = '+'.join(s) #如果是字符串，将+号加入到oldbay每一个元素中间 # # s9 = '_'.join(s) # print(s9) # l1 = ['oldboy','wusir','alex'] # s91 = '_'.join(l1)#如果是列表，将—加到每一个字符串中间(将列表转成一个字符串) # print(s91,type(s91))
10、replace(self, old, new, count=None)替换内容 ：例子：s10=s.replace('铁锤','钢蛋')
11、find(self, sub, start=None, end=None) 通过元素找索引 找不到返回-1；index(self, sub, start=None, end=None)通过元素找索引 找不到报错；建议用find
12、format(self, *args, **kwargs)格式化输出
例子：
res='我叫{}今年{}岁，爱好{}'.format('egon',18,'male') #要求字符串中的{}与format中的字符串相同 print(res) res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('egon',18,'male')#字符串中的{}中的元素位置是format中存在的就可以 print(res) res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)#format以键值对存在，字符串中{}内写上key就行 print(res)
13、公共方法：len()查询字符串的长度，例子：len(s)；count(self, sub, start=None, end=None)数字符串中元素出现的次数，可以设置开始位置和结束位置
14、isdigit(self)判断字符串是否全部由数字组成；isalpha(self)判断字符串是否全部由字母组成；isalnum(self)判断字符串是否由字母+数字组成；
例子： # i = '123a' # if i.isdigit(): # i = int(i) # else: # print("输入有误...")
15、encode(self, encoding='utf-8', errors='strict'
3、列表：list
3.1、增、删、改、查
# list # 1索引、切片 # 增、删、改、查 # 增加：append insert extend # 删除：pop() remove() clear() # 删除列表：del list(内存中删除列表) # del l[1] 按索引删除 # 切片删除 del l[:3] li = ['aa','b','alex','wusir'] #增加 # li.append('taibai') # li.insert(1,'ttt') # li.extend('abc')#字符串增加，如果只有一个元素，只增加一个；循环迭代增加 # li.extend(['aaa','qqqq','rrrr'])#列表循环增加 #修改 # li[0]='AAA'#按索引去改 # li[:2]='qwe'#按切片去修改 修改是删除切片范围内的数据，将新元素全部替换进去 # li[:2]=['ewq','fff',123] #删除 # li.pop() # li.pop(2) # li.remove('aa') # li.clear() # del li[0] # del li # print(li) #查 索引、切片、循环：for(循环数据类型) # for i in li: # print(i,type(i)) #全部转成字符串输出
3.2、其他方法：count(s)数数、 len(s)求s长度、index(self, value, start=None, stop=None)查元素的位置 、sort()对数字排序、 reverse()对列表反转
#其他方法：count(数数) len(长度) index() sort() reverse() # li = [2,3,5,1,6] # li.sort(reverse=True)#对列表中的数字进行排序，默认false正序 # li.sort() # print(li) # li = [3,2,4,2,1,5,2,5] # print(li.count(2)) # print(len(li)) # for i in range(len(li)): # print(i) # i +=1 # li = ['aa','b','alex','wusir'] # print(li.index('alex')) # li.reverse() # print(li) #练习 # l1 = [1, 2, 'alex', 'wusir',['oldboy', 'ritian', 99], 'taibai'] # # alex 大写 # # l1[2]=l1[2].upper() # # print(l1) # #追加女神 # # l1[4].append('女神') # # print(l1) # # print(l1[-2][1] ) # # l1[-2][1] = l1[-2][1].capitalize() # # print(l1) # # print(l1[:3]) # l1[-2][2] = str(l1[-2][2] +1) # print(l1)
copy:方法
import copy
list
li = [1,2,3,[33,44]]
l1=li
l2=li.copy()# 浅复制，儿子的数据不变，孙子的数据之前统一引用
l22=copy.copy(li)#同上
l3=copy.deepcopy(li)#深复制，儿子、孙子都不变
li[0]=55
li[3][0]=66
print(l1)
print(li)
print(l2)
print(l22)
print(l3)
enumerate 循环中有两个元素 和字典相似，for循环字典是也是k、v两个
li = ["手机", "电脑", '鼠标垫', '游艇']
# for i,j in enumerate(li):
# print(i+1,j)
# 1 手机
# 2 电脑
# 3 鼠标垫
# 4 游艇
# for i,j in enumerate(li,1):
# print(i,j)
# 1 手机
# 2 电脑
# 3 鼠标垫
# 4 游艇
for i in enumerate(li,1):
print(i)
# (1, '手机')
# (2, '电脑')
# (3, '鼠标垫')
# (4, '游艇')
4、字典
#dict #增 和 setdefault() #删 通过健删除 pop()、clear()、del()(删除整个字典或键值对)、popitem() #字段的pop 可以默认值 pop('name','没有此key ') #改：直接改 、update()字典1覆盖添加到字典2中 #查 直接查、dic.get('name','没有此key') #keys() values() items() #分别赋值： # a,b=1,2 # a,b,c=['alex','wusir','taibai'] # a,b=b,a #a,b值互换 #len #fromkeys 构建字典
嵌套 :字典中创建字典
4.1、增、删、改、查
#增 # dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', } # # dic['high']=18 # # print(dic) # # dic['name']='alex' # # print(dic) # # dic.setdefault('high',19) # # print(dic) # # dic.setdefault('name','aaa') # # print(dic) # #删 # # print(dic.pop('name')) # # print(dic.pop('name1','不存在key')) # # print(dic) # # dic.clear() # # print(dic) # # print(dic.popitem()) #随机删除 3.6后字典为有序的 # # print(dic) # # del dic # # print(dic) # # del dic['name'] # # print(dic) # #改 # # dic['name']='wusir' # # print(dic) # # dic2 ={'name':'alex','weight':75} # # dic2.update(dic)#将dic的键值对覆盖添加到dic2中，dic不变 # # print(dic2) # #查 # print(dic['name']) # print(dic.get('name')) # print(dic.get('name1','不存在key'))
#for i in dic: 和for i in dic.keys() 一样都是按键来循环
#另外一种：for k,v in dic:
print(k,v) 分别打印k,v的值
4.2、其他方法：len()、keys()、values() 、fromkeys(*args, **kwargs)构建字典 fromkeys(seq[, value]))、setdefault(self, k, d=None)添加键值对、update(self, E=None, **F)
fromkeys 批量增加字典的value值，key可以是字符串、列表、元组等
# fromkeys # seq = ('name', 'age', 'sex') # dict = dict.fromkeys(seq) # print(dict)#{'name': None, 'age': None, 'sex': None} # dict = dict.fromkeys(seq, 10) # print(dict)#{'name': 10, 'age': 10, 'sex': 10} # s='abc' # dict = dict.fromkeys(s) # print(dict)#{'a': None, 'b': None, 'c': None} # dict = dict.fromkeys(s, 10) # print(dict)#{'a': 10, 'b': 10, 'c': 10} # s=['a','b','c'] # dict=dict.fromkeys(s) # print(dict){'a': None, 'b': None, 'c': None} # dict=dict.fromkeys(s,'aaa') # print(dict)#{'a': 'aaa', 'b': 'aaa', 'c': 'aaa'}
4.3、例题:
dic = { 'name_list':['b哥', '张帝', '人帅', 'kitty'], '老男孩':{ 'name':'老男孩', 'age': 46, 'sex': 'ladyboy', }, } # 1,['b哥', '张帝', '人帅', 'kitty']追加一个元素，'骑兵' dic['name_list'].append('骑兵') print(dic) # 2，将kitty全部变成大写。 dic['name_list'][-1] = dic['name_list'][-1].upper() print(dic) # 3，将老男孩 改成oldboy。 dic['老男孩']['name'] = 'oldbay' print(dic) # 4，将ladyboy首字母大写。 dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize() print(dic)
5、元组
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
#增加 不可修改（儿子级不能改，孙子级可以修改，比如中嵌套列表） #for循环 #索引、切片 #其他count() index() 通过元素找索引 len()
#创建空元组：tup1 = ();
#元组与元组连接：(1, 2, 3) + (4, 5, 6)
#元组复制：('Hi!',) * 4
#创建一个元素的元组：tu=(1,) tu2=('s',)
6、集合
知识点回顾：可变类型是不可hash类型，不可变类型是可hash类型
作用：去重，关系运算
定义：可以包含多个元素，用逗号分割，集合的元素遵循三个原则：
1.每个元素必须是不可变类型（可hash，可作为字典的key）
2.没有重复的元素
4.无序
1、关系测试。交集、并集、子集、差集。。。 in not in
2、去重（列表的去重）
集合的增、删除、去重
# set1 = {1,'alex',False,(1,2,3)} # l1 = {1,1,2,2,3,3,4,5,6,6} # l2 = list(set(l1)) #去重 # print(l2) set1 = {'alex','wusir','ritian','egon','barry'} # #增 # set1.add('666') # print(set1) #update # set1.update('abc')#将abc元素分别加入 # print(set1) #删 # set1.remove('alex') # 删除一个元素 # print(set1) # set1.pop() # 随机删除一个元素 # print(set1) # set1.clear() # 清空集合 # print(set1) # del set1 # 删除集合 # print(set1)
关系测试。交集、并集、子集、差集：
# set1 = {1,2,3,4,5} # set2 = {4,5,6,7,8} #交集 & intersectio # print(set1 & set2) # print(set1.intersection(set2)) #并集 | union # print(set1 | set2) # print(set1.union(set2)) #差集 - difference # print(set1 - set2) # print(set1.difference(set2)) #反交集 ^ symmetric_difference # print(set1 ^ set2) # print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8} # 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)) # s = frozenset('barry') # s1 = frozenset({4,5,6,7,8}) # print(s,type(s)) # print(s1,type(s1))
7、数据类型的补充：
7.1再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错
再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错
l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩'] #1 # del l1[1::2] # print(l1) # # for i in range(len(l1)): # print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩'] # # ['alex', 'wusir', 'taibai', 'barry', '老男孩'] # # ['alex', 'taibai', 'barry', '老男孩'] # # ['alex', 'taibai', 'barry', '老男孩'] # print(i) # 0 1 2 3 # if i % 2 == 1: # del l1[i] # print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩'] # # ['alex', 'taibai', 'barry', '老男孩'] # # ['alex', 'taibai', 'barry'] # print(i) # 0 1
7.2range 可定制的数字列表
# for i in range(10): # print(i) # for i in range(1,10): # print(i) # for i in range(1,10,2): # print(i) # for i in range(10,1,-1): # print(i) # print(range(10)) # for i in range(len(l1)-1,-1,-1): # if i % 2 == 1: # del l1[i] # print(l1)
7.3 dict 再循环字典时，不要改变字典的大小。
# dic = {'k1':'v1','k2':'v2','k3':'v3','r':666} # l1 = [] # for i in dic: # if 'k' in i: # l1.append(i) # # print(l1) # # for i in l1: # del dic[i] # print(dic)
7.4tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
tu1 = (1) print(tu1,type(tu1)) tu2 = ('alex') print(tu2,type(tu2)) tu3 = (['alex',1,2]) print(tu3,type(tu3))
8、小数据池：
#id == is # a = 'alex' # b = 'alex' # print(a == b) # 数值 # print(a is b) # 内存地址 # print(id(a)) #python中 有小数据池的概念。 # int -5 ~256 的相同的数全都指向一个内存地址，节省空间。 # str：s = 'a' * 20 以内都是同一个内存地址 #只要字符串含有非字母元素，那就不是一个内存地址 #深浅copy #赋值运算，它们共用一个列表 # a = [1,2,3] # b = a # a.append(666) # print(a,b)#a,b同时增加666，公用一个内存地址 #浅copy 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始 # l1 = [1,2,3] # l2 = l1.copy() # l1.append(666) # print(l1,l2) l1增加了666，l2不增加666 # print(id(l1),id(l2)) 内存地址不一样 # l1 = [1,2,3,[22,33]] # l2 = l1.copy() # l1[-1].append(666) # print(l1,l2) # print(id(l1[-1]),id(l2[-1])) 一样都会增加666， #对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始， # 指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性 #深copy 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。 # import copy # l1 = [1,2,3,[22,33]] # l2 = copy.deepcopy(l1) # l1[-1].append(666) # print(l1,l2) # print(id(l1[-1]),id(l2[-1]))
9、编码
9.1编码历史及方式：
编码: ascii：字母，数字，特殊字符。 万国码：unicode ： A: 0000 0010 0000 0010 两个字节，表示一个字符。 中: 0000 0010 0000 0010 两个字节，表示一个字符。 升级： A: 0000 0010 0000 0010 0000 0010 0000 0010 四个字节，表示一个字符。 中: 0000 0010 0000 0010 0000 0010 0000 0010 四个字节，表示一个字符。 占空间，浪费资源。 utf-8：最少用一个字节，表示一个字符. A: 0000 0010 欧洲：0000 00100000 0010 中文：0000 00100000 00100000 0010 gbk国标。 A: 0000 0010 中： 0000 0010 0000 0010 python3x: 1,不同编码之间的二进制是不能互相识别的。 2,python3x str内部编码方式（内存）为unicode 但是，对于文件的存储，和传输不能用unicode bytes类型：内部编码方式（内存）为非unicode #对于英文 str: s = 'laonanhai' 表现形式 内部编码方式 unicode bytes: s1 = b'laonanhai' 表现形式 内部编码方式 非unicode （utf-8,gbk,gb2312....） #对于中文： str： s = '中国' print(s,type(s)) bytes： s1 = b'\xe4\xb8\xad\xe5\x9b\xbd' print(s1,type(s1))
9.2编码例子:
#对于英文 # s = 'laonanhai' # print(s,type(s)) # # s1 = b'laonanhai' # print(s1,type(s1)) #对于中文： # s = '中国' # print(s,type(s)) # # s1 = b'\xe4\xb8\xad\xe5\x9b\xbd' # print(s1,type(s1)) #转化 # s = 'laonanhai' # s2 = s.encode('utf-8') #str -->bytes encode 编码 # s3 = s.encode('gbk') # print(s2,s3) # s = '中国' # s2 = s.encode('utf-8') #str -->bytes encode 编码 # # s3 = s.encode('gbk') # # print(s2) # # print(s3) # ss = s2.decode('utf-8') # bytes ---> str decode 解码 # print(ss)
10、zip函数的用法：
10.1 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
例子： li = [1,2,3,4] s='abdf' d = 'qwer,def' t={'name':1,'age':2,'a':2,'f':3} for i in zip(li,s,d,t): print(i) 打印结果： (1, 'a', 'q', 'name') (2, 'b', 'w', 'age') (3, 'd', 'e', 'a') (4, 'f', 'r', 'f')
li = [1,2,3,4]
for i in zip(li[:],li[1:]):
print(i)
结果：
(1, 2)
(2, 3)
(3, 4)
10.2 zip可以将字典的键值对互换然后存在列表中
例子： t={'name':1,'age':2,'a':2,'f':3} z = list(zip(t.values(),t.keys())) print(z) 结果： [(1, 'name'), (2, 'age'), (2, 'a'), (3, 'f')]
12、map 方法的用法：内置函数 遍历序列，对序列中每个元素进行操作，最终获取新的序列
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表
语法：map(function, iterable, ...)
function -- 函数，有两个参数
iterable -- 一个或多个序列
1、
>>>def square(x) : # 计算平方数 ... return x ** 2 ... >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25]
2、 和1 的结果一样，采用匿名定义函数，别叫方便 >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] 3、 # 提供了两个列表，对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]
#4、用map来处理字符串，将列表中的字符串统一加一个后缀_sb，比如：alex_sb
name = ['alex','wusir','taibai']
new_name= list(map(lambda i:i+'_sb',name))
5、字符串(str)、列表(list)、元组()tuble、集合（set）、列表中嵌套字典等都可以使用map
name='alex'
newname=list(map(lambda i:i+'_sb',name)) 或 newname=tuple(map(lambda i:i+'_sb',name))
l = [{'name':'alex'},{'name':'wusir'}]
l1 = list(map(lambda x:x['name'] + '_sb' , l))#x随意定义，x['name']取字典值
注：map的数据是什么类型？
6、使用map将 type_choices 中元组转成字典
12、lambda 匿名函数
