一，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}
集合-->字典 : 可以但是键和值的顺序可能会反
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
