一,python基础
强类型语言,动态语言--------------解释型语言
注释
## 单行注释 以'#'开始 :#............... ## 多行注释 格式:''' '''
快捷键
关键字
-
布尔运算关键字。and、or、not。
-
控制流关键字。if、else、elif、while、for、break、continue、pass。
-
函数关键字。def、return、lambda。
-
异常处理关键字。try、except、finally、raise。
-
类与对象关键字。class、object、is、super。
-
其他关键字。import、from、as、global、nonlocal、del、assert、in、with、yield。
语句
能够完整的表达某个意思,用最短的代码来完成逻辑闭环。称之为语句。
输出语句
print("我是输出语句")
输入语句
在控制台内,输入内容
input(“请输入内容”)
缩进格式
普通的语句,从左边开始写
语句块:首行不需要缩进
函数快:注意逻辑缩进
变量
1.会变的量。在python,不需要声明变量。
2.变量使用之前,必须要先赋值
3.python中允许同时出现多个变量进行赋值
变量的声明
变量声明: 变量值=值 ,右侧的值放在左侧的变量中 如果这个变量第一次出现,创建 如果这个变量再次出现,则修改变量的值 name="xxx" name=xxx name="yyy" name=yyy
变量的命名规则·
所有自己命令的内容都叫做 标识符 命名规则: 1.数字,字母,下划线组成,数字不能开头 2.见明之意 3.驼峰明名法 4.不能和系统关键字重名 5.不能和保留函数重名 6。严格区分大小写
常量
常量不会改变,在程序运行过程中,是不会发生改变的。
命名规则: 所有的字母都是大写。
数据类型
##数据类型 ''' 两大类: 可变数据类型: 列表,字典,集合 不可变数据类型: 数字,字符串,布尔,元组,冰冻集合 ''' ''' 数字类型------number 三大类:int(整形),float(浮点),complex(复数) '''
数字
''' #十进制整数 以0b开头 decimal=10#二进制整数 binary=0b1010101 #八进制整数 以0o开头 oct=0o2473272 #十六进制整数 以0x开头 hex=0x44832 ''' #将一个数值,按照8进制来转换2,10,16 num="52" #8->2 print(f"8进制的{num}-->2进制:",bin(int(num,8))) #8->10 print(f"8进制的{num}-->10进制:",(int(num,8))) #8->16 print(f"8进制的{num}->2进制:",hex(int(num,8)))
字符串类型
''' 字符串:由多个文本或字符组成的一句话 表述方法: "", '', '''''' ''' s="那个女孩对我说:'说我是一个小偷'" print(type(s)) s1='''那个女孩对我说: 说我是一 个小偷''' print(s1)
字符串的模式
''' 字符串的模式: f"" :格式化 ,字符串的{} 里面写上变量 b"":字符转化为二进制 r"": raw字符串,字符串中所有的内容都会简单字符 转义字符: \ 转义字符后面的第一个字符转换成别的含义 \t \n \r \" \' \\ ''' ## f"" print({18}) ## b"" print(b"asd") print("D:\\my\\a.txt") print(r"D:\my\a.txt")
布尔
bool True False
字符串
1.字符串的基础
字符串属于不可变数据类型,不能直接修改字符串的本身,数字也属于不可变数据类型。
字符串的三种创建方式:
‘ ’
“ ”
‘’‘ ’‘’
1.三引号创建文本内容时,会自动解析换行符,控制台输出也换行
2.双引号,单引号 换行 自动加上括号,控制条输出不换行
字符串是一个可迭代对象,因此可以使用for循环来遍历,可以通过list等方法转换。可以通过下标获取字符串中的字符。
s = "待到春来九月八,我花开后百花杀"
1.字符串的索引
1.1获取每个字符
# 取出每一个字符 for i in s: print(i, end="") print()
1.2 把字符串转化为列表
print(list(s))
1.3 把字符串转化为一个元组
print(tuple(s))
1.4获取指定字符
# 获取指定字符 '来' print(s[3]) # 最后一个字符 字符串[-1] print(s[-1])
2.字符串的切片
''' 字符串[start : end : step] start:开始下标。默认:0 end : 结束下标 。默认:1 step :截取步长 ''' 字符串切片 包头不包尾 print(s[1:8]) ''' 字符串格式化: %s %d %f :占位符 "{}".format(): 大括号占位符 f"{变量}" :上述方法的简写 ''' ''' 字符串是一个不可变数据类型, 所有对于字符串的修改操作,都会产生一个新的字符串 '''
2.字符串判断类型
2.1 字符串.isalnum() 至少有一个字符并且所有字符都是数字和字母构成,返回True 只要包含一个特殊字符,就返回False
s1 = "12132a单露1 " ##汉字也是字母
2.2 字符串.isalpha() 至少有一个字符并且所有字符都是字母构成,返回True
s2 = "wwad" print(s2.isalpha())
2.3 字符串.isdecimal() 至少有一个字符并且字符串只包含数字,则返回True
s3 = "10086d" print(s3.isdecimal()) #False
2.4字符串.isdigit() 至少有一个字符并且字符串只包含数字,则返回True 识别unicode编码 # \u00b2为unicode的一个编
s4 = "\u00b2" print(s4.isdigit())
2.5 ==字符串.isnumeric() 至少有一个字符并且字符串中只包含数字,则返回true ##阿拉伯数字和汉字数字
s5 = "432423贰" print(s5.isnumeric())
2.6 字符串.istitle() 是否是一个标题化的格式 ,每个单词的首字母大写
s6 = "Hello World" print(s6.istitle())
2.7 字符串.isspace() 如果字符串只有空格,则返回True
s7 = " " print(s7.isspace())
2.8 字符串.islower() 如果字符串中至少有一个区分大小写的字母 ,并且所有字母都是小写,则返回True
s8 = "ddddddd" print(s8.islower())
2.9 字符串.isupper() 如果字符串中至少有一个区分大小的字母 并且所有字母都是大写,则返回True
s9 = "AAAA" print(s9.isupper())
3.字符串的查找与替换
''' @Project :code @File :3.字符串的查找与替换.py @IDE :PyCharm @Author :至高造物主 @Date :2024/3/7 14:05 ''' ''' 字符串.startswitch(str) 判断字符串是否以str开头 字符串.endswith(str) 判断字符串是否以str结尾 字符串.find(str,start=0,end=len()) 查找str在字符串中的下标,start和end可以确定查找范围 找不到返回-1 字符串.rfind(str,start=0,end=len()) 查找str在字符串中的下标,start和end可以确定查找范围 只不过是从右开开始找 如果找不到,报错 ''' song = "thatgirlyaagirlss" # 字符串.startswitch(str) print(song.startswith("that")) # 字符串.endswith(str) print(song.endswith("away")) ##3.字符串.find(str,start=0,end=len()) # 查找str在字符串中的下标,start和end可以确定查找范围 # 找不到返回-1 ##第一个字符的索引 print(song.find("girl", 4, 8)) # 4 ##找不到返回-1 print(song.find("girl", 4, 7)) # -1 ##4. 字符串.rfind(str,start=0,end=len()) # 查找str在字符串中的下标,start和end可以确定查找范围 # 只不过是从右开开始找 # 如果找不到,报错 # print(song.rfind("girl", 7, 14)) # 5 # print(song.rfind("girl", 0, 9)) # ##5. 字符串.replace(oldStr,newStr) # 要将字符串中旧字符串oldStr,全部替换为新字符串newStr s3 = "哈哈哈哈,你真有意思" print(s3.replace("真有", "什么"))
4.字符串的大小写转换
''' 字符串的大小写转换 字符串.lower(): 把字符串中所有大写的字母,全部转化为小写 字符串.upper(): 把字符串中所有的小写字母,全部转换为大写 字符串.swapcase(): 把字符串中所有大写的字母,全部转化为小写,小写的字母,全部转化为大写 字符串.title(): 把字符串中每个单词的首字母大写,其他字母小写 字符串.capitalize() : 只有首字母大写 ''' ##1. 字符串.lower() s1 = "helLo WoRld" print(s1.lower()) ##2. 字符串.upper() print(s1.upper()) ##3. 字符串.swapcase() print(s1.swapcase()) ##4. 字符串.title() print(s1.title()) ##5. 字符串.capitalize() print(s1.capitalize())
5.字符串去掉空白字符
''' @Project :code @File :5.字符串去掉空白字符.py @IDE :PyCharm @Author :至高造物主 @Date :2024/3/7 14:41 ''' ''' 字符串.lstrip() : 去除左侧空白 字符串.rstrip() : 去除右侧空白 字符串.strip() : 去除两侧空白 ''' str1 = " hello world " # 去除左侧 print(str1.lstrip()) # 去除右侧 print(str1.rstrip()) # 去除两侧 print(str1.strip())
6.字符串文本对齐
''' @Project :code @File :6.字符串文本对齐.py @IDE :PyCharm @Author :至高造物主 @Date :2024/3/7 14:45 ''' ''' 字符串.ljust(width,sep) : 字符串居左,一共有width宽度,其余位置用sep填充 字符串.rjust(width,sep) : 字符串居右,一共有width宽度,其余位置用sep填充 字符串.center(width,sep) : 字符串居中,一共有width宽度,其余位置用sep填充 ---sep 默认为" " ''' s = "welcome" print(s.ljust(20, "♥")) print(s.rjust(20, "♥")) print(s.center(20, "♥"))
7.字符串的拆分与链接
''' ''' ##1.字符串.partition(str) # --- 将 字符串拆分为多个字符串 组成一个元祖 # ---- str之前 ,str , str后之后 s = "aaaaBBBBcccc" ##2.字符串.rpartition(str) # --- 从后往前将 字符串拆分为多个字符串 组成一个元祖 # ---- str之前 str str后之后 ##3.字符串.split(str) ##以 str 分割 字符串为,返回结果为一个列表 s3 = "a-b-c-d-e-f" print(s3.split("-")) ##4. 字符串.splitlines() 几乎不用 ## 按照行分割: \r \n \r\n ##5. 字符串.join(序列) # 以字符串为分隔符,将序类中的每个元素拼接成一个新的字符串,元素必须是字符串类型 li=["A","B","C"] s5="-" print(s5.join(li))
8.字符串常用方法的总结
''' 字符串+字符串 字符串*数字 字符串的比较 字符串.splite(str) 字符串.strip(str) 字符串.count(str) 字符串.find() 字符串1 in 字符串2 '''
查看数据类型
type()
# 查看变量值的数据类型 print(type(decimal)) 、 # 浮点数 f = 3.145 print(type(f)) # 复数 c = complex(4, 5) print(type(c)) ''' 布尔值:O.o 本质上就是整数 True:真(非0) False:假(0) ''' b = True print(type(b))
数据类型的转换
''' 数据类型转换: 1.其他类型转整数: int(要转的内容) 2.其他类型转浮点数: float(要转的内容) 3..其他类型转字符串: str(内容) 4.其他类型转布尔值: bool() 结论: 0未False,非0True 字符串有内容为True 字符串无内容为False
其他类型转整数
向下取整
print(int(1.5)) #1
运算
print(int("10083")+3) #10086
进制转换
#进制转换 二----十 print(int("10010",2)) #18
布尔值转整数
print(int(True),int(False)) #1 0
其他类型转浮点数
浮点
# print(float("1.25")) #1.25
运算
# print(float("1.25")+1) #2.25
布尔转浮点
# print(float(True),float(False))
其他类型转字符串
数字转字符串
# print(str(10086)) #10086
其他类型转布尔值
bool()
规则:
0False,非0True
#0 为Flase print(bool(0)) #非0 为True print(bool(1)) print(bool(1.25))
字符串无内容为False
print(bool("")) #False
字符串有内容为True
print(bool("asd"))
运算符
算数运算符 比较运算符 逻辑运算符 三目运算符 赋值运算符
算数运算符:+ - * / % ** //
-
+
''' + 1.数值累加 2.连接符 拼接两个字符串 ''' print(1 + 2) # 3 print("1" + "2") # 12
-
-
''' # 减法 print(2 - 1) # 1 '''
3.*
print(2 * 2) # # *:字符串*数字 ,将字符串重复n边 print("a" * 5) # aaaaa
4.** 求幂
## (num1**num2) => num1的num2次方 print(2 ** 3) # 2的三次方 8
5./ 求除法的结果
##1. 直接的结果 #2.5 print(5 / 2)
6.// 求除法取整的结果
##2. // 整除 print(5 // 2) # 2
7.% 求余数
# % 求余数 print(5 % 2)
比较运算符
# > print(2 > 1) ###字符串的比较规则按照编码表进行比对 ###ASCII a:97 A:65 b:98 print('a' > 'b') ## 多个字母 从第一个到最后,比较如果能得到结果,直接给 print("aa" > "ac") # False ## # chr() ,数字通过编码表转化为字符 print(chr(98)) # b # ord() ,将字符转化为数字 print(ord("单")) print(ord("露")) word = "c" print(word.upper()) print(chr(ord(word) - 32)) == 比较对象
print(3>2>1>0) #支持连比
逻辑运算符
##3.逻辑运算符 ##and:且 or :或 not:非 ### and :两端的表达式必须都为真,才会返回True print(1 > 2 and 2 > 1) # False ### or :两端的表达式只要有一个为真,就会返回True print(1 > 2 or 2 > 1) # True ### not :取反 print(not 1 > 2) # True ### and写法 (number<10 and number>5) ### and简洁写法print(5< number <10)
逻辑运算符的特殊用法
''' 逻辑运算符的特殊用法: 如果两端为值,将值转化为bool根据以下规则返回对应的值。 1.and: 1真1假:返回假的值 全真:返回第二个值 全假:返回第一个值 2.or: 1真1假:返回真的值 全真:返回第一个值 全假:返回第二个值 ''' print(1 and 10) '''
赋值运算符
''' 赋值运算符 : = += -= /= %= **= //= 将右边的内容赋值给左边 ''' # = number = 10 # += number += 2 # -= number -= 2 # /= 除等 正确结果 number /= 2 # **= number **= 3 幂等 # //= 除法取整 number //= 2 ####1.多变量赋同样的值 a = b = c = 3 ####2.多变量赋不同的值 a1, b1, c1 = 1, 2, 3 ####3.交换变量的值 n1 = 10 n2 = 20 n1, n2 = n2, n1 print(n1, n2)
三元运算符
''' 三目运算符(三元运算符) # 值1 if 条件 值2 #### 如果条件是真,结果为值1,条件为假,结果为值2 ''' s = input("我能买这个吗?") r = '真开心' if s == '1' else '嘤嘤嘤' print(r)
成员运算符
in 和 not in
运算符的优先级:
####几种运算符的优先级 ### 算数运算符 > 比较运算符 > 逻辑运算符 > 三目运算符 > 赋值运算符
默认函数
''' 默认函数: input、print、len、max、min、sum... '''
查看关键字
# 查看系统关键字 import keyword #系统自动导入 print(keyword.kwlist)
查看虚拟环境(可以忽略)
conda config --show channels
*删除镜像
conda config --remove-key channels
添加虚拟环境
conda create -n 环境名 python=版本号
进入虚拟环境
conda activate 环境名
推出虚拟环境
conda deactivate
查看路径
conda env list
配置完后进行全局配置
虚拟环境
分支
# 流程控制语句 在程序的开发中,一共有三种流程控制语句: ## 顺序语句: 顺序语句就是按照顺序执行,从上到下,从右到左,依次执行。 ## 分支语句:条件语句就是根据条件判断,然后执行相应的语句。 重点:条件。 if 来判断条件 else 如果当下条件不成立,执行该语句下的代码 elif:增加其他可能
循环
循环语句:循环语句就是重复执行某段代码,直到满足条件。
for 循环
for 变量 in 可迭代对象: ## in 成员运算符 循环输出特定的代码
while
while 条件: 执行的代码块
列表List
为了方便大批量的变量管理,出现了一个变量的容器,称之为列表(list)。列表中的变量称为列表的元素。
==变量是值的容器,列表是变量的容器
列表的表示方法:
1.空列表: list() 或 []
2.非空列表:[值,值,值,值]
空列表
emptyList = list()
非空列表:列表中可以储存多种数据类型的变量
nonEmptyList = [1, 2, 3, 4, "黄焖鸡"] foodList = ["黄焖鸡", "地锅鸡", "西部来客炒鸡", "梅菜扣肉", "风味茄子"] print(f"遍历列表:{foodList}")
列表的操作
1.列表元素的获取
通过元素索引
# 长度从0开始到列表的长度-1 # 格式: 列表名字[索引] element=foodList[0] # 如果列表中元素的索引大于列表的长度,则会list index out of range
负索引
从-长度到-1结束----(现在了解)
print(f"获取列表下标:{foodList[3]}")
获取列表的长度
##2.获取列表的长度 ## 格式; 1.len(列表) ## 2. 列表.__len__() print(f"获取列表长度:{len(foodList)}")
2.列表元素的增加
print("😁😁😁😁列表元素的增加😁😁😁😁") ##-----------(1)..append(元素):在列表最后,追加元素 foodList.append("大闸蟹") print(f"1.通过append追加元素:{foodList}") ##-----------(2).. insert(下表,元素): 在指定下标,插入元素 foodList.insert(3, "麻辣小龙虾") print(f"2.通过insert 插入元素:{foodList}") ##-----------(3)..extend(列表):列表中的所有元素,追加进来 drinkList = ["可乐", "酸奶"] # extend foodList.extend(drinkList) print(f"3.extend追加:{foodList}") ##------------(4).. 列表 + 列表 :两个列表合并成一个新列表 li1 = [1, 3, 4] li2 = [5, 6] print(f"4.合并新列表:{li1 + li2}") ##------------(5). 列表 * 数字 :将该列表重复多少遍,生成新列表 newLi = li1 * 3 print(f"5.重复原列表生成一个新列表:{newLi}")
3.列表元素的删除
delList = [1, 2, 3, 4, 5, 6] print("😁😁😁😁列表元素的删除😁😁😁😁") ##-----------1. 列表.remove(元素):删除列表中的指定元素,没有该元素,会报错 delList.remove(2) print(f"1.remove删除指定元素:{delList}") ##-----------2. 列表.pop(): 删除列表的最后一个元素,返回值为该元素 item = delList.pop() print(f"2.pop删除最后一个元素,pop()返回值为列表的最后一个元素,该元素为:{item}") ##-----------3. pop(索引): 删除该下标的元素,并返回该下标所对应的元素 pops = delList.pop(1) print(f"3.pop删除指定下标下的元素并返回:{pops}") ##-----------4. del 列表(下标): 删除列表制定下标的元素 (了解) 删除该下标的元素,不返回 ##-----------5. clear() 清空列表 delList.clear() print(f"4.清空列表:{delList}")
li = ["a", "b", "c"] print(f"元素列表:{li}") ##----------列表[下标]=值 li[1] = "钞票" print(f"修改元素:{li}")
4.查询列表元素
判断查找
coltheslist = ["外套", "卫衣", "裤子", "T衫", "卫衣", "短裤"]
列表.index(元素):查找元素在这个列表的下标
ins = coltheslist.index("裤子") print(ins)
输出
2
列表.count(元素) ;查找这个元素在列表中出现的次数
counts = coltheslist.count("卫衣") print(f"2. 查找这个元素在列表中出现的次数{counts}")
输出
2
元素 in 列表: 元素在不在这个列表中 返回 True False
isExitInList = "卫衣" in coltheslist print(f"3. 元素 in 列表: 元素在不在这个列表中:{isExitInList}")
True
元素 not in 列表: 元素是否不在这个列表中 返回 True False
isNotExitInList = "卫衣" not in coltheslist print(f"4 元素 not in 列表: 元素在不在这个列表中:{isNotExitInList}")
5.实用操作
#### 实用操作: numList = [12, 21, 53, 3, 65, 43, 21, 16] ###1.列表.reverse(): 翻转列表 print(numList.reverse()) ###2. 列表的排序: 列表.sort() 正序排序 print(numList.sort()) ###3.列表.copy(): 生成一个该列表的浅拷贝样本 copyList = numList.copy() print(copyList)
6.浅拷贝
####浅拷贝 ##只复制第一层列表,列表中有嵌套,不会复制嵌套列表 ##副本列表,再修改嵌套列表元素的时候,原列表也会修改 li1 = ['a', [1, 2]] c1 = li1.copy() c1[1][0] = 3 c1[0] = "c" print(li1) print(c1)
7.深拷贝
import copy li2 = ['a', [1, 2]] c2 = copy.deepcopy(li2) c2[1][0]=3 c2[0]="c" print(li2) print(c2)
8.列表元素的遍历
li = ["🥁", "😈", "👼", "🦖", "🐕"]
1.普通遍历
###1. 普通的遍历 # ''' # for i in 可迭代对象 # ''' for i in li: print(i, end=" ") print(" ")
2.for循环遍历下标
#####2.1正序遍历 for i in range(len(li)): print(li[i], end=" ") print(" ") ###2.2倒序遍历 for i in range(len(li)-1, -1, -1): print(li[i], end=" ")
9.列表的切片
''' 列表切片:截取列表的一部分生成一个新的列表 列表[start:end:step] start :开始下标 默认0 end : 结束下标 默认-1 step :截取的步长,1 # 包含开始下标,不包含结束下标 '''
nameName = ["张三丰", "张无忌", "赵敏", "黄蓉", "黄药师", "梅超风", "小龙女"] ####截取前三个元素 print(nameName[0:3]) ###从下表0开始截取到5,步长为2 print(nameName[0:5:2]) ###从3开始切,切到最后 print(nameName[3:]) ##翻转列表 print(nameName[::-1]) li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] # 要把列表中的4到8项,翻转过来 # [1,2,3,4,9,8,7,6,5,0] start = li[:4] middle = li[4:9][::-1] end = li[9:] print(start + middle + end)
10.列表的比较
列表的比较可以用operate中的eq方法
a=[1,2]
b=[2,3]
c=[2,3]
operate.eq(list,list) 用于比较第一个列表是否等于第二个列表
输出
False
True
列表总结
Python包含以下函数:
序号 | 函数 |
---|---|
1 | len(list) 列表元素个数 |
2 | max(list) 返回列表元素最大值 |
3 | min(list) 返回列表元素最小值 |
4 | list(seq) 将元组转换为列表 |
Python包含以下方法:
序号 | 方法 |
---|---|
1 | list.append(obj) 在列表末尾添加新的对象 |
2 | list.count(obj) 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj) 将对象插入列表 |
6 | list.pop(index=-1) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
8 | list.reverse() 反向列表中元素 |
9 | list.sort( key=None, reverse=False) 对原列表进行排序 |
10 | list.clear() 清空列表 |
11 | list.copy() 复制列表 |
列表的高级用法
列表切片
''' 列表切片:截取列表的一部分生成一个新的列表 列表[start:end:step] start :开始下标 默认0 end : 结束下标 默认-1 step :截取的步长,1 # 包含开始下标,不包含结束下标 '''
nameName = ["张三丰", "张无忌", "赵敏", "黄蓉", "黄药师", "梅超风", "小龙女"] ####截取前三个元素 print(nameName[:3]) ###从下表0开始截取到5,步长为2 print(nameName[0:5:2]) ###从3开始切,切到最后 print(nameName[3:]) ##翻转列表 print(nameName[::-1])
列表推导式
[返回值 for i in list ]
列表内存
浅拷贝
元组(tuple)
元组(tuple)和列表相似:有序可重复 元组一旦生成,不可修改(第一层不可改)
元组的格式
元组的格式: 空元组
tuple() 或 ()
非空元组
t = (1, 2, 3, 4, 5, 3, 5)
元组元素的操作
1.1获取元素
print(t[0])
1.2如果元组中只有一个元素,需要在元素后加逗号
###不加逗号 括号表示优先运算,此时表示的是一个整数 t2 = (1,) type(t2) ######<class 'int'>
1.3元组中元素的类型可以不相同
t3 = (1, 2, [1, 2, 3])
元组中的第一层无法修改,但是如果元组中嵌套了别的可变容器,那么这个可变容器中的元素可以修改
t3[2][1] = 100 print(t3) # (1, 2, [1, 100, 3])
元组不可改变,但可以进行切片
因为切片返回的是一个新的元组,原来的元组不会改变,不可变数据类型有 int float str tuple
t4 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ###元组的切片操作跟列表的切片操作一样 t4[0:3] # 切 取前3个元素 print(t4[0:3]) # (1,2,3)
元组的解构
#####1.5 t5 = ("abc", "bcd", "ddl")
解构赋值 元组有多少个元素,变量就多少个
a, b, c = t5 print(a, b, c) # abc bcd ddl
解构赋值 可以忽略某些元素' _' 但其实是是赋值一个值,所以不会报错
## a1, _, c1 = t5 print(a1, c1)
元组和列表的区别
元组和列表的区别: 1.元组一旦创建是不可变的,列表是可变的 2.元组没有添加,删除,修改的方法 3.del也无法删除元组中的元素 4.tuple()可以将序列表变为元组 5.list也可以将序列变为列表 元组的优点: 1.元组的速度更快 2.元组对于数据更加安全 3.元组是不可变数据类型 元组的缺点: 不能变
集合(无序不可重复)
集合(set)是一个无序的不重复元素序列。集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合,元素之间用逗号 , 分隔, 或者也可以使用set() 函数创建集合。
集合的操作:
1.集合的创建
s = {1, "11", "12", 4} print(s) print(type(s)) -----<class 'set'>
2.集合元素的操作
2.1集合添加元素
s.add("56")
2.2添加多个
集合.update(): 可以添加一个或多个元素。
s.update(["aa", "da", "das", "sdad", "das"]) print(s)
注意:1.集合添加元素是按照一个一个字添加的。
2.update() ()内可以添加要追加的集合或列表。
2.3移除元素
集合.remove(元素)
##1.集合.remove(元素) remove移除找不到的元素会报错 ##2.集合.discard(元素): 如果元素不存在,不会报错 s1 = {"小乔", "兰陵王", "百里守约", "女娲", "西施", "王昭君"} print(s1) ##1.集合.remove(元素)
集合.discard(元素)
s1.remove("百里守约") print(s1) ##2.集合.discard(元素) s1.discard("兰陵王") print(s1)
2.4集合耳朵运算
集合运算: 交集: & 两个集合的公共元素 并集: | 两个集合的非公共元素 差集: - 获得运算符左侧的集合的独有元素 对称差集: ^ 获得公共元素外的其他元素
s3 = {"a", "b", "c", "d"} s4 = {"a", "b", "e", "f"} ##交集:两个集合的公共元素 print(s3 & s4) # {"a","b"} ##并集:两个集合的非公共元素 print(s3 | s4) # {"a","b","c","d","e","f"} ##差集:获得运算符左侧的集合的独有元素 print(s3 - s4) # {"c","d"} ##对称差集:获得公共元素外的其他元素 print(s3 ^ s4) # {"c","d","e","f"}
集合与其他元素的相互转化
使用set可以将元素或列表或者字符串转化为集合,去除重复元素,前提是对元素顺序没有要求 。
t4 = [1, 1, 1, 2, 2, 3, 3, 3, 4, 9] s = list(set(t4)) print(s)---[1,2,3,4,9]
注意:
1.集合中只能存储数字,字符串,元组,布尔等不可变数据类型 2.集合用大括号表示 {} 但是如果集合中没有元素,只能用set(),创建一个空集合 因为{}表示一个字典,因此空集合用set() 3. '''
冰冻集合
''' 冰冻集合: frozenset() 跟普通的集合相比,不能修改。冰冻集合不可变数据类型 '''
字典(无序可重复)
字典是另一种可变容器模型,且可存储任意类型对象。字典是双列集合: dicrionary(dict)字典中的每一个元素,由两个数组成,称之为键值对key:value键(key):必须是不可变数据类型值(key):数据类型随意。
字典的操作
1.创建一个空字典
###创建一个空字典 :{} 或 dict()
2.字典的创建
d = { "姓名": "g光头", "性别": "男", "年龄": 18, "爱好": ["唱", "跳", "rap", "篮球", "足球", "篮球"] }
3.字典键值的增加
字典的增加与删除 ##如果键不存在,则会添加 ##如果键已存在,则会覆盖
3.1 字典名[键] = 值
d["salary"] = 18888
3.2 字典.update(字典2)
字典2中所有的键值对会添加到字典1中
d2={"height":"198","city":"郑州"} d.update(d2)
4.字典键值的修改
字典名[要修改的键]=要修改的值
d["salary"] = 20000
5.字典删除数据
5.1 字典.pop(key)
pop会移除对应的键值对,返回结果为value
ageNum = d.pop("年龄") print(ageNum)
5.2 字典.popitem()
==popitem()移除字典中最后添加的键值对,然后把删除的键值对做成元组返回==
print(d.popitem())
==可以通过元组的解构来获取删除的key和value==
key, value = d.popitem() print(key,value)
清空
# d.clear() # print(len(d)) ---{}
7.查找字典中的元素
字典.get(key) :返回key对应的值
value1 = d.get("salary")
字典[key]也可以获取可以对应的值,如果key不存在,
value2 = d[年龄]
key in 字典 查找字典中是否有key
key not in 字典 查找字典中是否没有key
获取键值 键 值
##5. 字典.keys() 返回字典中所有的键组成的列表 [] print(d.keys()) ##6. 字典.values() 返回字典中所有的值组成的列表 [] # print(d.values()) ##7. 字典.items() 返回字典中所有的键值对组成的列表 [(),()] # print(d.items())
字典的遍历
dictOne = {"a": 1, "b": 2, "c": 3}
1.循环键
for i in dictOne: print(i, dictOne[i])
2.循环键
###2. 第二种: 循环键 for i in dictOne.keys(): print(i, dictOne[i])
3.通过元组的解构
for key, value in dictOne.items(): print(key, value)
总结:
组合数据类型的转换:
其他转字典: dict() 元组-->字典 : (a,b)-->{a:b} 列表-->字典 : [(a,b),(c,d)]-->{a:b,c:d} 集合-->字典 : 可以但是键和值的顺序可能会反