Python基本数据类型
参考：老男孩Python全栈开发第三期
https://www.bilibili.com/video/av21663728/?p=82
一、数字类型
数字类型的特性：
- 只能存放一个值
- 一经定义，不可更改
- 直接访问
分类：整型，布尔，浮点，复数
# 1、将字符(串)转化为int # aa = "123" # bb = int(aa) # print(type(bb),bb) # # a = "123a" # print(type(a),a) #<class 'str'> 123a # # b = int(a) # 数字 字母混合，转化失败 # print(type(b),b) # 2、字母按16进制转化为数字 # num = "b" # v2 = int(num, base=16) # 十六进制中 a b c d e f 分别表示 10 11 12 13 14 15 # print(v2) # 3、当前数字的二进制，至少用n位表示 # age = 5 # 二进制表示 # 1 1 # 2 10 # 3 11 # 4 100 # 5 101 # 当前数字的二进制，至少用n位表示 # r = age.bit_length() # print(r) ###进制转换 bin(8) #将十进制转换成二进制 0b1000 oct() #将十进制转换成八进制 hex() #将十进制转换成十六进制 4、浮点型 b = "12" float(b) 5、数字运算符 + 加 - 减 * 乘 / 除 % 取余 如：5%3=2 // 取整 如：5//3=1 6、isdigit() 检测字符串是否只由整数组成，内部自动调用了int()方法 >>"123".isdigit() True >>"123a".isdigit() False >>"12.35".isdigit() False
二、字符串
def main(): str1 = 'hello, world!' # 通过len函数计算字符串的长度 print(len(str1)) # 13 # 字符串首字母大写 print(str1.capitalize()) # Hello, world! # 字符串变大写 print(str1.upper()) # HELLO, WORLD! # 从字符串中查找子串所在位置 print(str1.find('or')) # 8 print(str1.find('shit')) # -1 # 与find类似但找不到子串时会引发异常 # print(str1.index('or')) # print(str1.index('shit')) # 检查字符串是否以指定的字符串开头 print(str1.startswith('He')) # False print(str1.startswith('hel')) # True # 检查字符串是否以指定的字符串结尾 print(str1.endswith('!')) # True # 将字符串以指定的宽度居中并在两侧填充指定的字符 print(str1.center(50, '*')) # 将字符串以指定的宽度靠右放置左侧填充指定的字符 print(str1.rjust(50, ' ')) str2 = 'abc123456' # 从字符串中取出指定位置的字符(下标运算) print(str2[2]) # c # 字符串切片(从指定的开始索引到指定的结束索引) print(str2[2:5]) # c12 print(str2[2:]) # c123456 print(str2[2::2]) # c246 print(str2[::2]) # ac246 print(str2[::-1]) # 654321cba 将字符串倒序 print(str2[-3:-1]) # 45 # 检查字符串是否由整数构成 print(str2.isdigit()) # False # 检查字符串是否都是以字母构成 print(str2.isalpha()) # False # 检查字符串是否以数字和字母构成 print(str2.isalnum()) # True str3 = ' jackfrued@126.com ' print(str3) # 获得字符串修剪左右两侧空格的拷贝 print(str3.strip()) if __name__ == '__main__': main()
字符串练习题
练习1：
# 1、字符串大小写转换，判断是否都是大小写
# name1 = "xiong"
# v1 = name1.upper()
# print(v1)
#
# name2 = "LiuXiang"
# v2 = name2.upper()
# print(v2)
# v3 = name2.lower()
# print(v3)
# 首字母大写
# test = "aLex"
# v = test.capitalize()
# v2 = test.title()
# print(v,v2) #Alex Alex
"""所有变小写，casefold更牛逼，很多未知的对相应变小写"""
# test = "xIong"
# v1 = test.casefold() #特殊字符的对应
# print(v1)
# v2 = test.lower() #普通的英文大小写对应
# print(v2)
# v3 = test.islower()
# v4 = test.lower()
# #
# v5 =test.isupper()
# v6 = test.upper()
# print(v3,v4)
# print(v5,v6)
"""大小写转换"""
# test = "xiONg"
# print(test.swapcase())
"""center 设置宽度，并将内容居中"""
# 20 代指总长度
# * 空白未知填充，一个字符，可有可无
# test = "xIong"
# v = test.center(20,"*")
# v = test.center(20,"中")
# print(v)
"""ljust rjust 左右填充"""
# test = "xiong"
# v1 = test.ljust(20,"*") #左对齐 右边空白部分填充指定单个字符
# v2 = test.rjust(20,"&") #右对齐 左边空白部分填充指定单个字符
# print(v1)
# print(v2)
"""count 去字符串中寻找子序列的出现次数"""
# test = "aLexalexr"
# v = test.count('ex')
# print(v)
#
# test = "aLexalexr"
# v = test.count('ex',5,8) #从第5位到第8位
# print(v)
# 欠
# encode
# decode
"""endwith 以什么什么结尾,startwith 以什么什么开始"""
# test = "alex"
# v = test.endswith('ex')
# v = test.startswith('ex')
# print(v)
""" S.expandtabs(20) 断句以20个断开"""
# test = "12345678 9"
# v = test.expandtabs(6)
# print(v,len(v)) #12345678 9 13
# #（123456）（78 ）（9）段成3份 补空格
#
# test2 = "username email password
xiong 1351655382@qq.com 1232456
zhang 1567891232@qq.com 127891456
wang 25645382@gmail.com asd12374"
# v2 = test2.expandtabs(20)
# print(v2)
"""find 从开始往后找，找到第一个之后 返回索引，获取其未知"""
# > 或 >=
# test = "alexalex"
# ## 未找到 -1 （推荐）
# v = test.find('ex')
# print(v)
# index找不到，报错 忽略
# test = "alexalex"
# v = test.index('8')
# print(v)
"""格式化，将一个字符串中的占位符替换为指定的值"""
# test = 'i am {name}, age {a}'
# print(test)
# v = test.format(name='alex',a=19)
# print(v)
#
# test = 'i am {0}, age {1}'
# print(test)
# v = test.format('alex',19)
# print(v)
"""格式化，传入的值 format_map {"name": 'alex', "a": 19}"""
# test = 'i am {name}, age {age}'
# v1 = test.format(name='df',a=10)
# v2 = test.format_map({"name": 'alex', "a": 19})
# ## 上面两种功能相同 注意写法
# print(v1," ",v2)
# ！！！补充：
# format(*args, **kwargs) 当参数有**kwargs 时format传入的字典前要加上 **
# v3 = test.format({"name":"xiong","age":26}) #这样会报错
# test1 = 'i am {name}, age {age}'
# v3 = test1.format(**{"name":"xiong","age":26}) #正确写法
# test2 = "my name is {0} age is{1}"
# v4 = test2.format(*["oldwang",32])
# print(v3) #i am xiong, age 26
# print(v4)
# 字符串中是否只包含 字母和数字
# test = "123"
# v = test.isalnum()
# print(v)
# 判断字符串是否都是字母(汉字)
# test1 = "asdf"
# test2 = "asdf熊"
# v1 = test1.isalpha()
# v2 = test2.isalpha()
# print(v1,v2)
"""判断字符串是否都是数字"""
# test3 = "1234②"
# v3 = test3.isdecimal() #只十进制数字 1 2
# v4 = test3.isdigit() #还能够识别特殊的一些数字格式 如： ②
# test4 = "125一②三四"
# v5 = test4.isnumeric() #还能识别中文 二 三
# test5 = "②二45贰"
# v6 = test5.isnumeric() #总结下来：isnumeric识别数字能力最强
# print(v3,v4,v5,v6)
"""字母 数字 下划线(不能以数字开头):标识符 def class"""
# a1 = "xiong_2"
# a2 = "_liu"
# a3 = "class"
# a4 = "2class"
# print(a1.isidentifier())
# print(a2.isidentifier())
# print(a3.isidentifier())
# print(a4.isidentifier())
# 判断字符串中打印出来 是否存在不可显示的字符 制表
换行
# test = "asdfg dfawe"
# print(test.isprintable()) #False
# 判断是否全部是空格
# test = "adf fds"
# test2 = " "
# print(test.isspace()) #False
# print(test2.isspace()) #True
# 判断是否是标题（标题所有单词的首字母大写）以及转化为标题
# test = "He fei Gong ye Da Xue"
# print(test.istitle())
# test1 = test.title()
# print(test1)
# print(test1.istitle())
"""join 将字符串中每个元素按照指定分隔符进行拼接"""
# test = "你是风儿我是沙"
# v1 = "_".join(test) #你_是_风_儿_我_是_沙
# v2 = " ".join(test) #你 是 风 儿 我 是 沙
# print(v1)
# print(v2)
#对比数组的join方法
# " ".join(["china",'henan','xinyang','luoshan']) #'china henan xinyang luoshan'
"""strip() """
#去除左/右（左右）空格
# test = " xiong "
# print(test.lstrip()) # "xiong "
# print(test.rstrip()) # " xiong"
# print(test.strip()) # "xiong"
#去除
# test1 = " xiong
"
# print(test1.lstrip()) #去掉左边的
# print(test1.rstrip()) ##去掉右边的
# print(test1.strip()) #去除左右的
# 去除指定字符，优先最多匹配 只要匹配到都能去除(原字符串不变)
# test2 = "xiongjtsx"
# v1 = test2.rstrip("1sxng") #xiongjt
# print(v1)
# v2 = test2.strip("ongsx") #iongjt
# print(v2)
# # 最多使用---去除指定的确切字符
# test3 = "xiongjtsx"
# v3 = test2.rstrip("jtsx") #xiong
# print(v3,test2)
# 指定对应与替换
# test1 = "aeiou"
# test2 = "12345"
# v = "adfsfewtipotpioriwohjkbnuusfnbaoiaplkonbvu"
# m = str.maketrans(test1,test2)
# new_v = v.translate(m)
# print(new_v)
"""split 分割"""
# test = "testasdqewtsxi"
# v = test.partition("s") #分割为3份 遇到第一个匹配就分
# print(v) #('te', 's', 'tasdqewtxi')
# v2 = test.rpartition("s")
# print(v2) #('testa', 's', 'dqewtxi')
#
# # S.split() 返回值没有分割符
# test = "testasdqewtsxi"
# v3 = test.split("s") #['te', 'ta', 'dqewt', 'xi']
# v4 = test.split("s",1) #['te', 'tasdqewtsxi'] #指定用前1个s来分割，分为 1+1份
# v5 = test.split("s",2) #['te', 'ta', 'dqewtsxi'] #指定用前2个s来分割，分为 2+1份
# print(v3)
# print(v4)
# print(v5)
# 只根据
分割，True 保留
,False 不保留
# test = "ajdgkler
iotng
iewyih
"
# print(test.splitlines()) # 默认是 False ['ajdgkler', 'iotng', 'iewyih']
# print(test.splitlines(True)) #['ajdgkler
', 'iotng
', 'iewyih
']
# 欠 正则表达式 分割，可以指定分割符 分割长度，是上面两种合集
# 以xxx开头 ，以xxx结尾
# test = "xiuiothfn"
# v = test.startswith("xo")
# print(v)
# print(test.endswith("fn"))
""" replace 替换 """
# test = "abdghdiabocnzkaboqthabdgdrgf"
# v1 = test.replace("ab","熊")
# print(v1)
# v2 = test.replace('ab',"熊",2) #替换前2个
# print(v2)
"""######################## 8个需要掌握的基本魔法 ##########################"""
"""
# join
# split
# find
# strip
# replace
# upper/isupper
# lower/islower
# format()
"""
"""####################### 6个要掌握的灰魔法 ###############"""
# 索引/下标 获取字符串某一个字符
# test = "xiong"
# print(test[2])
# 切片
# print(test[1:3]) #左闭右开 io
# print(test[:3]) #xio
# print(test[:-1]) #xion
#长度
#python3 len() 获取当前字符串由几个字符组成 ,Python2 len() 组成字符串字节长度
# print(len(test))
# test1 = "中华人民共和国"
# print(len(test1))
# for循环
# for wd in "xiongjt":
# print(wd)
# 创建连续数字,通过设置步长指定一组数
# v1= range(0,100) #Python3 对此优化，定义了但内存中未创建，只有for循环了才会创建
# v2 = range(0,100,5) #0 5 10 15 。。。95
# for i in v2:
# print(i)
# 注意： len() "_".join() for循环 索引 切片 ，在列表 字典 元组 其他的数据类型里面也可以用
"""################# 1个深灰魔法######################"""
# 原理：
# 字符串一旦创建，不可修改
# 一旦修改或者拼接，都会重新生成新字符串
练习2：
"""7、如有一下变量 n1=5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示？""" # n1 = 5 # print(n1.bit_length()) # 布尔 # "" ===> 假 # " " ===> 真 # 0 ===> 假 # 其他 ===> 真 # a = 123 # b = "xiong" # bool(a) # bool(b) """ 22、请用代码实现： a. 利用下划线将列表的每一个元素拼接成字符串，li ＝ "alexericrain" b. 利用下划线将列表的每一个元素拼接成字符串，li ＝ ['alex', 'eric', 'rain'] （可选） """ # v1 = "_".join("alexericrain") # v2 = "_".join(['alex', 'eric', 'rain']) # print(v1) # print(v2) """ 24、实现一个整数加法计算器： 如：content = input('请输入内容：') # 如： 5+9 或 5+ 9 或 5 + 9 """ # test = " 5+ 3" # v1,v2 = test.split("+") #test.split("+") 返回一个列表 # print(int(v1)+int(v2)) """ 27、制作趣味模板程序 需求：等待用户输入名字、地点、爱好，根据用户的名字和爱好进行任意现实 如：敬爱可亲的 xxx，最喜欢在 xxx 地方 xxx """ # strVal = input(">>>") # strVal = "敬爱可亲的{0}，最喜欢在{1}地方干{2}" # v1 = "小小" # v2 = "ktv" # v3 = "唱歌" # v = strVal.format(v1,v2,v3) # print(v) """ 28、制作随机验证码，不区分大小写。 流程： - 用户执行程序 - 给用户显示需要输入的验证码 - 用户输入的值 用户输入的值和显示的值相同时现实正确信息；否则继续生成随机验证码继续等待用户输入 """ # def check_code(): # import random # checkCode = "" # for i in range(4): # current = random.randint(0,4) # if current != i: # temp = chr(random.randint(65,90)) # else: # temp = random.randint(0,9) # checkCode += str(temp) # return checkCode # # while(True): # code = check_code() # print(code) # strVal = input(">>>") # if(strVal.upper() == code): # print("验证成功！") # break """ 29、开发敏感词语过滤程序，提示用户输入内容，如果用户输入的内容中包含特殊的字符： 如 "苍老师" "东京热"，则将内容替换为 *** """ # strVal = input(">>>") # strVal = "东京热里面的演员我最喜欢苍老师" # v = strVal.replace("苍老师","***").replace("东京热","***") # print(v) """ 30、制作表格 循环提示用户输入：用户名、密码、邮箱 （要求用户输入的长度不超过 20 个字符，如果超过则只有前 20 个字符有效） 如果用户输入 q 或 Q 表示不再继续输入，将用户输入的内容以表格形式大隐 """ # s = "username pwd email " # while True: # exitloop = input("继续输入Y，退出输入N>>>") # if (exitloop.lower() == "n"): # break # username = input("输入用户名>>>") # pwd = input("输入密码>>>") # email = input("输入邮箱>>>") # # if len(username) > 20: # print("输入的用户名太长了，重新输入") # username = input("输入用户名>>>") # template = "{0} {1} {2} " # v = template.format(username, pwd, email) # # s += v # # ret = s.expandtabs(20) # print(ret)
三、列表
# list 类 # 列表 是有序的，元素可以修改 # 1、列表格式 # li = [1,12,5,'xiong',[11,56,3,"wang"],True,{"age":12},(1,2,9,22)] # 列表中的元素可以是 数字、字符(串)、列表、字典、集合等任意数据类型 # print(li) """ 2、取值方式""" # 2-1、索引取值 # print(li[2]) # # 2-2、切片取值 # print(li[2:5]) # # 2-3、for循环取值 # for item in li: # print(item) """ 3、修改""" # 3-1、索引修改 # li[1] = 120 # print(li) # # 3-2、切片修改 # li[2:4] = [[11,22,33],"xjt"] # print(li) """ 4、删除""" # 4-1、切片删除 # del li[1] # print(li) # # 4-2、索引删除 # del li[2:5] # print(li) """ 5、in 操作""" # v1 = "xiong" in li # print(v1) # v2 = "wang" not in li # print(v2) # v3 = "wang" in li[4] # print(v3) """ 6、列表转化为字符串""" #6-1、列表项不都是 字符串，要用for循环 li = [11,22,65,"xiong",True] # s = "" # for item in li: # s += str(item) # print(s) # print("_".join([str(item) for item in li])) #列表推导式，其实原理就是for循环 #6-2、列表项全部都是 字符串 可以用join 拼接 # li = ["china","zhejiang","ningbo","haisu"] # v = "_".join(li) # print(v) """######################## list 类中提供方法 ########################""" # 专业说法： 对象.方法(...) #li.append() li对象调用了append方法 """1、append() 在愿列表后 追加元素,一个参数""" # li = [11,22,33,22,44] # li.append(44) # print(li) # 2、clear() 清空列表，无参数 # print(li.clear()) # 3、copy() （浅）拷贝，无参数，有接收值 # v = li.copy() # print(v) # 4、count() 计算元素出现个数，一个参数 # print(li.count(22)) """5、extend() 追加列表元素,参数:可迭代对象""" # li = [11,22,33,22,44] # print(li+[111,222,333]) # li.extend(['xiong',68,20]) #[11, 22, 33, 22, 44, 'xiong', 68, 20] # print(li) # li.extend("浙江省") #[11, 22, 33, 22, 44, 'xiong', 68, 20, '浙', '江', '省'] # print(li) """6、index(self, value, start=None, stop=None) 从前往后找 找到返回索引，找不到会报错，可传递3个参数 """ # li = [11, 22, 33, 22, 44, 'xiong', 68, 20] # v = li.index(222) # print(v) """7、insert(self, index, p_object) 在指定索引index 插入p_object""" # li = [11, 22, 33, 22, 44, 'xiong', 68, 20] # li.insert(2,'zhejiang') # print(li) """ 8、pop(self, index=None) 删除值，默认删除索引index 为-1 ,有返回值时 返回弹出的值""" # li = [11, 22, 33, 22, 44, 'xiong', 68, 20] # li.pop() # print(li) # li.pop(2) # print(li) # v = li.pop(-2) # print(v) """ 7、remove(self, value) 删除列表中指定值，如果列表中有多个相同值，删除第一个。可以用一个循环删掉所有指定值""" # li = [11, 22, 33, 22, 44, 'xiong', 68, 20] # li.remove(22) # print(li) # PS:删除 # pop() remove() del li[0] li.clear() # 列表.pop() #pop() 按索引删除 # 列表.remove() #remove() 按值删除,如果列表中有多个相同值，删除第一个。可以用一个循环删掉所有指定值 # li = ['hello',1,2,6,2,5,8,33,1,2,6] # print(li) # while (2 in li): # li.remove(2) # print(li) # print(li) # 8、reverse(self) 反转列表 # 9、sort(self, key=None, reverse=False,cmp=None) 列表排序 # li = [11,55,33,88,66,12] # li.sort() #[11, 12, 33, 55, 66, 88] 从大到小 # li.sort(reverse=True) #[88, 66, 55, 33, 12, 11] 从小到大 # print(li) # 欠：cmp key # 补充：字符串创建后，不可修改 # li = [11,22,66,5] # print(li[0]) # li[0] = 999 # print(li) # # s = "xiong" # print(s[0]) # s[0] = "abc" #TypeError: 'str' object does not support item assignment
练习：
list1 = [1, 3, 5, 7, 100,3,5,3]
# print(list1)
# list2 = ['hello'] * 5
# print(list2) #['hello', 'hello', 'hello', 'hello', 'hello']
# # 计算列表长度(元素个数)
# print(len(list1))
# # 下标(索引)运算
# print(list1[0])
# print(list1[4])
# # print(list1[5]) # IndexError: list index out of range
# print(list1[-1])
# print(list1[-3])
# list1[2] = 300
# print(list1)
# # 添加元素
# list1.append(200)
# list1.insert(1, 400) #指定位置插入值
# list1 += [1000, 2000]
# print(list1)
# print(len(list1))
# # 删除元素
# list1.remove(3)
# if 1234 in list1:
# list1.remove(1234)
# del list1[0]
# print(list1)
# # 清空列表元素
# list1.clear()
# print(list1)
"""
# 列表也可以做切片操作，通过切片操作可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 循环遍历列表元素
for fruit in fruits:
print(fruit.title(), end=' ') #fruit.title() 首字母大写
print()
# 列表切片
fruits2 = fruits[1:4]
print(fruits2)
# fruit3 = fruits # 没有复制列表只创建了新的引用
# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3)
fruits4 = fruits[-3:-1]
print(fruits4)
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5)
"""
"""
#实现了对列表的排序操作
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
list3 = sorted(list1, reverse=True)
# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
print(list1)
print(list2)
print(list3)
print(list4)
# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)
"""
# li = ["12","25","32","2"]
# li2 = sorted(li,key=lambda x:int(x))
# print(li,li2) #['12', '25', '32', '2'] ['2', '12', '25', '32']
#按照年龄排序
# array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
# array = sorted(array,key=lambda x:x["age"])
# print(array) #[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
#先按照成绩降序排序，相同成绩的按照名字升序排序：
# d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
# l = sorted(d1, key=lambda x:(-x['score'], x['name']))
# print(l) #[{'name': 'alice', 'score': 38}, {'name': 'christ', 'score': 28}, {'name': 'darl', 'score': 28}, {'name': 'bob', 'score': 18}]
"""列表的生成表达式"""
"""列表的生成器对象"""
"""
import sys
f = [x for x in range(1, 10)]
print(f)
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)
# 相当于[x + y for x in 'ABCDE' for y in '1234567']
for x in 'ABCDE':
for y in '1234567':
print(x+y)
# 用列表的生成表达式语法创建列表容器
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
f = [x ** 2 for x in range(1, 100)]
print(sys.getsizeof(f)) # 查看对象占用内存的字节数
print(f)
# 请注意下面的代码创建的不是一个列表而是一个生成器对象
# 通过生成器可以获取到数据但它不占用额外的空间存储数据
# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间) 不占空间但是耗费时间
f = (x ** 2 for x in range(1, 100))
print(sys.getsizeof(f)) # 相比生成式生成器不占用存储数据的空间
print(f)
for val in f:
print(val)
"""
"""
# 用yield方法将普通函数改造成生成器
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
# def main():
# for val in fib(20):
# print(val)
gen = fib(10)
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
"""
四、元组
# 列表 # list # li = [11,22,33] """ 元组内可以是Python的任意数据类型 元组的一级元素不能 修改、增加、删除，可以查看（只读） """ # tuple # tu = (11,22,33,"xiong",[1,6,5],[(33,22,),"oldwang"],{1:11},(1,2,3),{11,22,33}) # 索引取 # print(tu) # print(tu[3]) # 切片取 # print(tu[:4]) # for 循环,tuple 是可迭代对象 # for item in tu: # print(item) # s = "zhejiang" # li = ["ningbo","haisu"] # tu = ("dongqiao","hexiao","yingcheng_square",) # # v1 = tuple(s) #('z', 'h', 'e', 'j', 'i', 'a', 'n', 'g') # print(v1) # v2 = tuple(li) #('ningbo', 'haisu') # print(v2) # v3 = list(tu) #['dongqiao', 'hexiao', 'yingcheng_square'] # print(v3) # # # tuple 元素都是字符串时可以用join()方法 转化为字符串 # v4 = "_".join(tu) #dongqiao_hexiao_yingcheng_square # print(v4) # 补充：元组的一级元素不能 修改、增加、删除 # tu = (11,22,"xiong",[(33,66,)],True,(123,456,),) # tu[3][0] = "修改了二级元素" # print(tu) # tu[3][0][0] = 12345 # 报错，(33,66) 又是元组 不能修改一级元素 """########################tuple 类中提供的方法#############################""" # count(self, value) 统计value出现的次数 tu = (11,22,"xiong",[(33,66,)],True,(123,456,),22,333,) print(tu.count(22)) # index(self, value, start=None, stop=None) 查找value 找到返回索引，找不到报错 # print(tu.index(22))
练习：
1 """ 2 Python 的元组与列表类似，不同之处在于元组的一级元素不能修改，在前面的代码中我们已经不止一次使用过元组了。 3 顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。 4 """ 5 ''' 6 t = ('徐峥', 38, True, '中国北京') 7 print(t) 8 # 获取元组中的元素 9 print(t[0]) 10 print(t[3]) 11 12 # 遍历元组中的值 13 for member in t: 14 print(member) 15 16 # 重新给元组赋值 17 # t[0] = '王大锤' # TypeError 18 # 变量t重新引用了新的元组原来的元组将被垃圾回收 19 t = ('王大锤', 20, True, '云南昆明') 20 print(t) 21 22 # 将元组转换成列表 23 person = list(t) 24 print(person) 25 # 列表是可以修改它的元素的 26 person[0] = '李小龙' 27 person[1] = 25 28 print(person) 29 # 将列表转换成元组 30 fruits_list = ['apple', 'banana', 'orange'] 31 fruits_tuple = tuple(fruits_list) 32 print(fruits_tuple) 33 ''' 34 """ 35 这里有一个非常值得探讨的问题，我们已经有了列表这种数据结构，为什么还需要元组这样的类型呢？ 36 37 1、元组中的元素是无法修改的。 38 事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象 39 （一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护； 40 另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。 41 一个不变对象可以方便的被共享访问）。 42 所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。 43 44 2、元组在创建时间和占用的空间上面都优于列表。 45 我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间，这个很容易做到。 46 我们可以在ipython中使用魔法指令%timeit来分析创建同样内容的元组和列表所花费的时间，下图是我的macOS系统上测试的结果。 47 也可以直接用Python导入timeit模块测试 48 >>> from timeit import timeit 49 >>> timeit("[1,2,'xiong',25]") 50 0.05179392 51 >>> timeit("(1,2,'xiong',25)") 52 0.013960106666665695 53 >>> import sys 54 >>> sys.getsizeof([1,2,'xiong',25]) 55 96 56 >>> sys.getsizeof((1,2,'xiong',25)) 57 80 58 """
五、字典
""" 字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”， 键和值通过冒号分开。下面的代码演示了如何定义和使用字典。 """ scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82} # 通过键可以获取字典中对应的值 print(scores['骆昊']) print(scores['狄仁杰']) # 对字典进行遍历(遍历的其实是键再通过键取对应的值) for elem in scores: print('%s ---> %d' % (elem, scores[elem])) #也可以遍历字典每一项（键和值） for k,v in scores.items(): print(k,"===>",v) # 更新字典中的元素 scores['白元芳'] = 65 scores['诸葛王朗'] = 71 scores.update(冷面=67, 方启鹤=85) print(scores) if '武则天' in scores: print(scores['武则天']) print(scores.get('武则天')) # get方法也是通过键获取对应的值但是也可以设置默认值(源字典没有被修改)，scores.get('武则天', 60) 返回设置的值 print(scores.get('武则天', 60)) print(scores) # # 删除字典中的元素 print(scores.popitem()) #删除最后一个 print(scores.popitem()) print(scores.pop('骆昊', 100)) print(scores) # 清空字典 scores.clear() print(scores)
"""###################### dict基本知识 ##########################""" # 1、字典的value可以是任意值 # info = { # "k1":11, # "k2":"xiong", # "k3":True, # "k4":[ # 111,222,333,{ # "k41":"zhejiang", # "k42":1234, # "k43":(111,222,333,"nb") # } # ], # "k5":(1,2,3,6), # } # print(info) # 2、字典的key，列表、字典不能作为字典的key，数字、元组、布尔值可以作为key # info = { # 1:True, # "k1":123, # True:444, # # [1,2,3]:"zhejiang", # TypeError: unhashable type: 'list' # (11,22,33):"nb", # # {"kk1":11,"kk2":22}:123, #TypeError: unhashable type: 'dict' # } # print(info) # 注意：字典中key相同时，后面一个会覆盖前一个 # 布尔值 True False 作为key 自动转化为 1 0 # info = {1:"xiong",1:"zhejiang",2:"nb",0:"shanghai",True:'beijing',False:"shenzhen"} # print(info) #{1: 'beijing', 2: 'nb', 0: 'shenzhen'} # 3、字典是无序的 # 4、字典取值 # v = info["k4"][3]["k43"][0] # 111 # print(v) # 5、字典支持 del 删除 # info = { # "k1":11, # "k2":"xiong", # "k3":True, # "k4":[ # 111,222,333,{ # "k41":"zhejiang", # "k42":1234, # "k43":(111,222,333,"nb") # } # ], # "k5":(1,2,3,6), # } # del info["k1"] # print(info) # del info["k4"][3]["k42"] # print(info) # 6、字典for循环 # info = { # "k1":11, # "k2":"xiong", # "k3":True, # "k4":[ # 111,222,333,{ # "k41":"zhejiang", # "k42":1234, # "k43":(111,222,333,"nb") # } # ], # "k5":(1,2,3,6), # } # 默认是循环key # for i in info: # print(i) #k1 k2 k3 k4 k5 # (与上面相同)循环key # for k in info.keys(): # print(k) ##k1 k2 k3 k4 k5 # 循环values # for v in info.values(): # print(v) #11 xiong True [111, 222, 333, {'k41': 'zhejiang', 'k42': 1234, 'k43': (111, 222, 333, 'nb')}] (1, 2, 3, 6) # 循环dict逗号分隔的项(即keys+values) # for item in info.items(): # print(item) #('k1', 11) ('k2', 'xiong') ('k3', True) # 用key value 去接收item # for k,v in info.items(): # print(k,"===",v) #k1 === 11 k2 === xiong k3 === True """dict的 in 方法""" info = {"k1":11,"k2":22} v1 = "k1" in info print(v1) #True v2 = 22 in info.values() print(v2) #True """########################### dict 类提供的方法 ###############################""" # 1、clear(self) 清空字典 # 2、v = info.copy() 浅拷贝 # 3、 # @staticmethod # known case #装饰器 直接通过 点方法调用： dict.fromkeys() # def fromkeys(*args, **kwargs) #第一个参数（可迭代对象）作为key，第二个参数作为value，生成相同value的字典 # v = dict.fromkeys([11,True,"xiong",(1,2,3,)],1234) # 生成的字典 {11: 1234, True: 1234, 'xiong': 1234, (1, 2, 3): 1234} # v = dict.fromkeys([11,True,"xiong",(1,2,3,)],[111,222,333,444,555]) # 生成的字典 {11: [111, 222, 333, 444, 555], True: [111, 222, 333, 444, 555], 'xiong': [111, 222, 333, 444, 555], (1, 2, 3): [111, 222, 333, 444, 555]} # print(v) """ 4、get(self, k, d=None) 通过key取字典值，key不存在时默认为None，也可以指定默认值，key存在时自动忽略默认值""" # info["k1"] 取值时 key不存在会报错 # info = {"k1":11,"k2":22} # v = info.get("k33") # print(v) #None # v1 = info.get("k33",'key不存在') # print(v1) #key不存在 """ 5、keys(self)""" # """ 6、values(self)""" # """ 7、items(self)""" # 8、pop(self, k, d=None) key不存在时返回默认值 d # popitem(self) 随机删除字典一项，返回key value # info = {"k1":11,"k2":22} # v = info.pop("k1",'key不存在') # print(info,v) #{'k2': 22} 11 # v1 = info.pop("k33",'key不存在') # print(info,v1) #{'k2': 22} 11 # i = info.popitem() # print(info,i) #{'k1': 11} ('k2', 22) # k,v = info.popitem() # print(info,k,v) #{'k1': 11} k2 22 # 9、setdefault(self, k, d=None) 设置值，已存在 不设置 获取当前key对应value，不存在 设置 获取设置值的value # info = {"k1":11,"k2":22} # v = info.setdefault("k33","xiong") # print(info,v) #{'k1': 11, 'k2': 22, 'k33': 'xiong'} xiong """ 10、update(self, E=None, **F) 更新dict，存在的 修改，不存在 更新上""" # info = {"k1":11,"k2":22} # info.update({"k1":"xiong","k33":123,"k44":[1,2,3]}) # print(info) #{'k1': 'xiong', 'k2': 22, 'k33': 123, 'k44': [1, 2, 3]} # 另一种写法 # 注意：**kwargs 在Python内部自动将 k1=v1,k2=v2 转化为{k1:v1,k2:v2} # info.update(k1="xiong",k33=123,k44=[1,2,3]) # print(info) #{'k1': 'xiong', 'k2': 22, 'k33': 123, 'k44': [1, 2, 3]} """###################dict方法总结######################""" """ # 最重要必记的方法： # keys() values() items() get() update() """
六、集合
""" 使用集合 Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。 """ # #初始化定义集合 # set1 = {1, 2, 3, 3, 3, 2} # print(set1) # print('Length =', len(set1)) # set2 = set(range(1, 10)) # print(set2) # #向集合中添加元素 # set1.add(4) # set1.add(5) # set2.update([11, 12,11]) # print(set1) # print(set2) # #删除集合中元素 # set2.discard(5) # # remove的元素如果不存在会引发KeyError # if 4 in set2: # set2.remove(4) # print(set2) # # 遍历集合容器 # for elem in set2: # print(elem ** 2, end=' ') # print() # # 将元组转换成集合 # set3 = set((1, 2, 3, 3, 2, 1)) # print(set3.pop()) # print(set3) # # 集合的交集、并集、差集、对称差运算 # print(set1 & set2) # # print(set1.intersection(set2)) # print(set1 | set2) # # print(set1.union(set2)) # print(set1 - set1) # # print(set1.difference(set2)) # print(set1 ^ set2) # # print(set1.symmetric_difference(set2)) # # 判断子集和超集 # print(set2 <= set1) # # print(set2.issubset(set1)) # print(set3 <= set1) # # print(set3.issubset(set1)) # print(set1 >= set2) # # print(set1.issuperset(set2)) # print(set1 >= set3) # # print(set1.issuperset(set3)) """ 说明： Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符（后面的章节中会讲到）， 上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如&运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。 """
# 集合：set # 1、不同元素组成 # 2、无序 # 3、集合中元素必须是不可变类型（数字、字符串、元组） 注意：可以通过 s=set(['alex','alex','sb']) 将列表变为集合 print(s) #{'alex', 'sb'}
集合基本方法：
"""# 集合：set # 1、不同元素组成 # 2、无序 # 3、集合中元素必须是不可变类型（数字、字符串、元组） 注意：可以通过 s=set(['alex','alex','sb']) 将列表变为集合 """ """###################### set内置方法 #########################""" """集合定义方式""" # s=set('hello') # print(s) # s=set(['alex','alex','sb']) print(s) #{'alex', 'sb'} # s={1,2,3,4,5,6} """#添加""" # s.add('s') # s.add('3') # s.add(3) # print(s) # s.clear() # print(s) """#浅拷贝""" # s1=s.copy() # s={'sb',1,2,3,4,5,6} """#随机删""" # s.pop() """#指定删除""" # s.remove('sb') # s.remove('hellol') #删除元素不存在会报错 # s.discard('sbbbb') #删除元素不存在不会报错 # print(s) # python_l=['lcg','szw','zjw','lcg'] # linux_l=['lcg','szw','sb'] # p_s=set(python_l) # l_s=set(linux_l) """ #求交集""" # print(p_s,l_s) # print(p_s.intersection(l_s)) # print(p_s&l_s) """ #求并集""" # print(p_s.union(l_s)) # print(p_s|l_s) """#差集""" # print('差集',p_s-l_s) # print(p_s.difference(l_s)) # print('差集',l_s-p_s) # print(l_s.difference(p_s)) """#交叉补集""" # print('交叉补集',p_s.symmetric_difference(l_s)) # print('交叉补集',p_s^l_s) # python_l=['lcg','szw','zjw','lcg'] # linux_l=['lcg','szw','sb'] # p_s=set(python_l) # l_s=set(linux_l) # print(p_s,l_s) # print('差集',p_s-l_s) # p_s=p_s-l_s # p_s.difference_update(l_s) # print(p_s) """两个集合没有交集""" # s1={1,2} # s2={2,3,5} # print(s1.isdisjoint(s2)) """子集""" # s1={1,2} # s2={1,2,3} # print(s1.issubset(s2)) #s1 是s2 的子集 # print(s2.issubset(s1)) #False # # print(s2.issuperset(s1)) #s2 是s1 的父集 # # s1={1,2} # s2={1,2,3} # s1.update(s2) #更新多个值 # s1.add(1,2,3,4) #更新一个值 # s1.union(s2) #不更新 # print(s1) # s1.update((22,32,)) # s1.update(['zhejiang','suzhou']) # print(s1) # # 集合是可变类型 # frozenset定义的集合是不可变集合 # s=frozenset('hello') # print(s) # names=['alex','alex','wupeiqi'] # # names=list(set(names)) #简单的去重 # print(names)
集合常用运算符：
in
not in
＝＝
！＝
<,<= 子集 issubset
>,>= 父集 issuperset
|,|= 并集 union
&.&= 交集 intersection
－,－= 差集 difference
^,^= 交叉补集 symmetric_difference
Python集合内置方法源码：
class set(object): """ set() -> new empty set object set(iterable) -> new set object Build an unordered collection of unique elements. """ def add(self, *args, **kwargs): # real signature unknown """ Add an element to a set. This has no effect if the element is already present. """ pass def clear(self, *args, **kwargs): # real signature unknown """ Remove all elements from this set. """ pass def copy(self, *args, **kwargs): # real signature unknown """ Return a shallow copy of a set. """ pass def difference(self, *args, **kwargs): # real signature unknown """ 相当于s1-s2 Return the difference of two or more sets as a new set. (i.e. all elements that are in this set but not the others.) """ pass def difference_update(self, *args, **kwargs): # real signature unknown """ Remove all elements of another set from this set. """ pass def discard(self, *args, **kwargs): # real signature unknown """ 与remove功能相同，删除元素不存在时不会抛出异常 Remove an element from a set if it is a member. If the element is not a member, do nothing. """ pass def intersection(self, *args, **kwargs): # real signature unknown """ 相当于s1&s2 Return the intersection of two sets as a new set. (i.e. all elements that are in both sets.) """ pass def intersection_update(self, *args, **kwargs): # real signature unknown """ Update a set with the intersection of itself and another. """ pass def isdisjoint(self, *args, **kwargs): # real signature unknown """ Return True if two sets have a null intersection. """ pass def issubset(self, *args, **kwargs): # real signature unknown """ 相当于s1<=s2 Report whether another set contains this set. """ pass def issuperset(self, *args, **kwargs): # real signature unknown """ 相当于s1>=s2 Report whether this set contains another set. """ pass def pop(self, *args, **kwargs): # real signature unknown """ Remove and return an arbitrary set element. Raises KeyError if the set is empty. """ pass def remove(self, *args, **kwargs): # real signature unknown """ Remove an element from a set; it must be a member. If the element is not a member, raise a KeyError. """ pass def symmetric_difference(self, *args, **kwargs): # real signature unknown """ 相当于s1^s2 Return the symmetric difference of two sets as a new set. (i.e. all elements that are in exactly one of the sets.) """ pass def symmetric_difference_update(self, *args, **kwargs): # real signature unknown """ Update a set with the symmetric difference of itself and another. """ pass def union(self, *args, **kwargs): # real signature unknown """ 相当于s1|s2 Return the union of sets as a new set. (i.e. all elements that are in either set.) """ pass def update(self, *args, **kwargs): # real signature unknown """ Update a set with the union of itself and others. """ pass def __and__(self, *args, **kwargs): # real signature unknown """ Return self&value. """ pass def __contains__(self, y): # real signature unknown; restored from __doc__ """ x.__contains__(y) <==> y in x. """ pass def __eq__(self, *args, **kwargs): # real signature unknown """ Return self==value. """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __ge__(self, *args, **kwargs): # real signature unknown """ Return self>=value. """ pass def __gt__(self, *args, **kwargs): # real signature unknown """ Return self>value. """ pass def __iand__(self, *args, **kwargs): # real signature unknown """ Return self&=value. """ pass def __init__(self, seq=()): # known special case of set.__init__ """ set() -> new empty set object set(iterable) -> new set object Build an unordered collection of unique elements. # (copied from class doc) """ pass def __ior__(self, *args, **kwargs): # real signature unknown """ Return self|=value. """ pass def __isub__(self, *args, **kwargs): # real signature unknown """ Return self-=value. """ pass def __iter__(self, *args, **kwargs): # real signature unknown """ Implement iter(self). """ pass def __ixor__(self, *args, **kwargs): # real signature unknown """ Return self^=value. """ pass def __len__(self, *args, **kwargs): # real signature unknown """ Return len(self). """ pass def __le__(self, *args, **kwargs): # real signature unknown """ Return self<=value. """ pass def __lt__(self, *args, **kwargs): # real signature unknown """ Return self<value. """ pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __ne__(self, *args, **kwargs): # real signature unknown """ Return self!=value. """ pass def __or__(self, *args, **kwargs): # real signature unknown """ Return self|value. """ pass def __rand__(self, *args, **kwargs): # real signature unknown """ Return value&self. """ pass def __reduce__(self, *args, **kwargs): # real signature unknown """ Return state information for pickling. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __ror__(self, *args, **kwargs): # real signature unknown """ Return value|self. """ pass def __rsub__(self, *args, **kwargs): # real signature unknown """ Return value-self. """ pass def __rxor__(self, *args, **kwargs): # real signature unknown """ Return value^self. """ pass def __sizeof__(self): # real signature unknown; restored from __doc__ """ S.__sizeof__() -> size of S in memory, in bytes """ pass def __sub__(self, *args, **kwargs): # real signature unknown """ Return self-value. """ pass def __xor__(self, *args, **kwargs): # real signature unknown """ Return self^value. """ pass __hash__ = None 查看 查看
补充：
字符串格式化的两种方式：
1、百分号方式
2、Format方式