Python基础语法学习记录
输出
将结果或内容呈现给用户
python
print("休对故人思故国,且将新火试新茶,诗酒趁年华")
# 输出不换行,并且可以指定以什么字符结尾
print("青山依旧在",end= ",")
print("几度夕阳红",end= "。")
2.数据类型
2.1 整型(int)
py
print(222)
print(2 ** 2) # 2的2次方
print(10 / 2)
2.2 字符串(str)
py
# 单引号和双引号一样
print("Hello World")
print("上海市浦东新区")
print("我是'艾伦'")
# """表示多行字符串
print("""
人生到处何所似,
应是飞鸿踏雪泥。
"""
)
对于字符串:
- 拼接:
+
- 乘:整型和字符串进行相乘,实现字符串重复出现N次并拼接
py
print(3 * "我想吃拉面")
2.3 布尔类型(bool)
bool类型种共有两个值:True/False
py
print(1 > 2)
print(False)
print(True)
print(1 == 1)
name = input("请输入你的用户名: ")
if name.lower() == "zed":
print(name + "登录成功")
else:
print("登录失败")
补充:
1 == 'Alan' # 可以比较
1 > 'Alan' # 不可以进行比较
2.4 数据类型转换
不同的数据类型有不同的功能,如果想要做转换,可遵循一个原则,想转换什么类型就让它包裹住
如:str(666)是将整型转化为字符串,int("888")是将字符串转为整型
类型转换
- 其他所有类型转为布尔类型时,除了空字符串、0以外其他都是True;
- 字符串转为整型时,只有是数字类型的字符串("669")才可转换为整型,其他都报错;
- 想要转换为哪种类型,就用这个类型的英文包裹一下就可以
str(...)
int(...)
bool(...)
3.变量
注意:
- 给变量赋值;
- 让age代指某个值;
py
name = "Zed"
age = 24
flag = 1 > 2
print(name)
print(age)
print(flag)
3.1 变量名的规范
三个规范:
- 变量名由字母、数字、下划线组成;
- 不能以数字开头;
- 不能用Python内置的关键字;
变量内存指向
情景一
python
name = "sushi"
在计算机的内存中创建一块区域保存字符串"sushi",name变量名则指向这块区域。
情景二
python
name = "sushi"
name = "alex"
在计算机的内存中创建一块区域保存字符串"sushi",name变量名则指向这块区域。然后又再内存中创建了一块域保存字符串"alex",name变量名则指向"alex"所在的区域,不再指向"sushi"所在区域(无人指向的数据会被标记为垃圾,由解释器自动化回收)
情景三
python
name = "sushi"
new_name = name
在计算机的内存中创建一块区域保存字符串"sushi",name变量名则指向这块区域。new_name变量名指向name变量,因为被指向的是变量名,所以自动会转指向到name变量代表的内存区域。
情景四
python
name = "sushi"
new_name = name
name = "alex"
在计算机的内存中创建一块区域保存字符串"sushi",name变量名则指向这块区域(灰色线), 然后new_name指向name所指向的内存区域,最后又创建了一块区域存放"alex",让name变量指向"alex"所在区域.
情景五
python
num = 18
age = str(num)
在计算机的内存中创建一块区域保存整型18,name变量名则指向这块区域。通过类型转换依据整型18再在内存中创建一个字符串"18", age变量指向保存这个字符串的内存区域。
4.注释
- 单行注释
py
# 声明一个name变量
name = 'Alan'
- 多行注释
py
"""
这是一个多行注释
这是一个多行注释
这是一个多行注释
这是一个多行注释
"""
5.输入
实现用户与程序之间的交互
py
# 接收用户输入的变量
name = input("请输入用户名: ")
特别注意:
用户输入的任何内容都是字符串;
6.条件语句
python
if 条件:
...
else:
...
6.1 基本条件语句
-
示例1
pythonusername = "sushi" password = "666" if username == "sushi" and password == "666": print("恭喜你,登录成功") else: print("登录失败")
-
示例2
pythonusername = "sushi" if username == "sushi" or username == "alex": print("VIP大会员用户") else: print("普通用户")
-
示例3
pythonnumber = 19 if number%2 == 1: print("number是奇数") else: print("number是偶数")
pythonnumber = 19 data = number%2 == 1 if data: print("number是奇数") else: print("number是偶数")
-
示例4
pythonif 条件: 成立
pythonprint("开始") if 5 == 5: print("5等于5") print("结束")
6.2 多条件判断
python
if 条件A:
A成立,执行此缩进中的所有代码
...
elif 条件B:
B成立,执行此缩进中的所有代码
...
elif 条件C:
C成立,执行此缩进中的所有代码
...
else:
上述ABC都不成立。
6.3 条件嵌套
python
if 条件A:
if 条件A1:
...
else:
...
elif 条件B:
...
模拟10086客服
python
print("欢迎致电10086,我们提供了如下服务: 1.话费相关;2.业务办理;3.人工服务")
choice = input("请选择服务序号")
if choice == "1":
print("话费相关业务")
cost = input("查询话费请按1;交话费请按2")
if cost == "1":
print("查询话费余额为100")
elif cost == "2":
print("交互费")
else:
print("输入错误")
elif choice == "2":
print("业务办理")
elif choice == "3":
print("人工服务")
else:
print("序号输入错误")
7. 循环语句
- while循环
pyth
while 条件:
...
...
...
- for循环
7.1 循环语句基本使用
py
num = 1
while num < 4:
print("2024发大财")
num += 1
7.2 break 终止循环
break,用于while循环中终止循环;
7.3 continue结束本次循环
continue, 在循环中用于结束本次循环,开始下一次循环;
7.4 while else
当while后的条件不成立时,else中的代码就会执行
python
while 条件:
代码
else:
代码
python
num = 1
while num < 5:
print("2024一夜暴富")
num += 1
else:
print("2024一定会发财")
8. 字符串格式化
8.1 %格式化
python
# 引入
name = "苏东坡"
age = 18
text = "我叫%s,今年%d岁" %(name,age)
python
message = "%(name)s你什么时候过来呀?%(user)s今天不在呀。" % {"name": "死鬼", "user": "李杰"}
print(message)
8.1.2 百分比特殊处理
python
text = "%s,这个片我已经下载了90%%了,居然特么的断网了" %"兄弟"
print(text)
# 输出:
兄弟,这个片我已经下载了90%了,居然特么的断网了
8.2 format格式化(推荐)
py
text1 = "我叫{0}, 今年{1}岁".format("Alan",19)
text2 = "我叫{0}, 今年{1}岁,真实姓名是{0}".format("Alan",19)
print(text1)
print(text2)
################################
text = "我叫{n1},今年18岁".format(n1="Alan")
text = "我叫{n1},今年{age}岁".format(n1="Alan",age=18)
text = "我叫{n1},今年{age}岁,真是的姓名是{n1}。".format(n1="Alan",age=18)
################################
# 先定义格式化字符串,再调用format方法传递参数
text = "我叫{0},今年{1}岁"
data1 = text.format("Alan",666)
data2 = text.format("alex",73)
address = "{0}市{1}区{2}街道"
print(address.format("上海","浦东新","溜溜"))
8.3 f格式化(Python3.6之后)
python
hobby1 = "打游戏"
hobby2 = "打球"
message = f"我喜欢{hobby1},还喜欢{hobby2}"
###
输出: 我喜欢打游戏,还喜欢打球
###
9. 运算符
9.1 算数运算符
9.2 比较运算符
9.3 赋值运算
9.4 成员运算
9.5 逻辑运算
10. Python数据类型
常见数据类型:
- int,整数类型
- bool,布尔类型
- str,字符串;
- list,列表类型;
- tuple,元组类型;
- dict,字典类型;
- set,集合类型;
- float,浮点型;
10.1 整型
10.1 定义
python
number = 10
age = 99
10.2 独有功能
无
python
v1 = 5
print(bin(v1)) # 0b101
# 调用v1(int)的独有功能,获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1) # 3
v2 = 10
print(bin(10)) # 0b1010
# 调用v2(int)的独有功能,获取v2的二进制有多少个位组成。
result2 = v2.bit_length()
print(result2) # 4
10.3 公共功能
加减乘除
python
v1 = 4
v2 = 8
v3 = v1 + v2
10.4 转换
在项目开发和面试题中经常会出现一些 "字符串" 和 布尔值 转换为 整型的情况。
python
# 布尔值转整型
n1 = int(True) # True转换为整数 1
n2 = int(False) # False转换为整数 0
# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值,然后再转换为 十进制整数,结果:v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值,然后再转换为 十进制整数,结果:v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8) # 把字符串看成八进制的值,然后转换为 十进制整数,结果:v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16) # 把字符串看成十六进制的值,然后转换为 十进制整数,结果:v1 = 89 (0x表示十六进制)
# 浮点型(小数)
v1 = int(8.7) # 8
所以,如果以后别人给你一个按 二进制、八进制、十进制、十六进制 规则存储的字符串时,可以轻松的通过int转换为十进制的整数。
10.5 其他
10.5.1 长整型
- Python3:整型(无限制)
- Python2:整型、长整形
在python2中跟整数相关的数据类型有两种:int(整型)、long(长整型),他们都是整数只不过能表示的值范围不同。
- int,可表示的范围:-9223372036854775808~9223372036854775807
- long,整数值超出int范围之后自动会转换为long类型(无限制)。
在python3中去除了long只剩下:int(整型),并且 int 长度不在限制。
10.5.2 地板除
-
Py3:
pythonv1 = 9/2 print(v1) # 4.5
-
py2:
pythonv1 = 9/2 print(v1) # 4
pythonfrom __future__ import division v1 = 9/2 print(v1) # 4.5
10.2 布尔型
10.3 字符串
python
"xxxx".方法名(参数)
s = "xxx"
s.方法名(...)
10.3.1 判断字符串是否以XX为开头startswith
py
# 案例
s.startswith("北京市")
10.3.2 判断字符串是否以XX结尾endswith
py
s.endswith("大厦")
10.3.3 判断字符串是否是整数
py
message.isdecimal()
10.3.4 判断字符串是否为十进制数
py
v1 = "123"
print(v1.isdecimal()) # True
v2 = "①"
print(v2.isdecimal()) # False
v3 = "123"
print(v3.isdigit()) # True
v4 = "①"
print(v4.isdigit()) # True
10.3.5 去除字符串两边的空格、换行符、制表符,得到一个新字符串
py
msg = " H e ll o啊,树哥 "
data = msg.strip()
print(data) # 将msg两边的空白去掉,得到"H e ll o啊,树哥"
msg = " H e ll o啊,树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉,得到"H e ll o啊,树哥 "
msg = " H e ll o啊,树哥 "
data = msg.lstrip()
print(data) # 将msg两边的空白去掉,得到"H e ll o啊,树哥 "
案例:
py
# 案例
code = input("请输入4位验证码:") # FB88 fb88
value = code.upper() # FB88
data = value.strip() # FB88
if data == "FB87":
print('验证码正确')
else:
print("验证码错误")
# 注意事项
"""
code的值"fb88 "
value的值"FB88 "
data的值"FB88"
"""
去除两边指定的内容:
py
msg = "哥H e ll o啊,树哥"
data = msg.strip("哥")
print(data) # 将msg两边的空白去掉,得到"H e ll o啊,树"
10.3.5 字符串变大写
python
msg = "my name is the flash"
data = msg.upper()
print(data) # MY NAME IS THE FLASH
10.3.6 字符串变小写
python
msg = "MY NAME IS THE FLASH"
data = msg.lower()
print(data) # my name is the flash
10.3.7 字符串的替换
python
data = "你是个好人,但是好人不合适我"
value = data.replace("好人","贱人")
print(data) # "你是个好人,但是好人不合适我"
print(value) # "你是个贱人,但是贱人不合适我"
# 案例
video_file_name = "喜剧片.mp4"
new_file_name = video_file_name.replace("mp4","avi") # "喜剧片.avi"
final_file_name = new_file_name.replace("喜剧","科幻") # "科幻片.avi"
print(final_file_name)
10.3.8 字符串的切割
py
data = "Alan|root|alan@qq.com"
result = data.split('|') # ["Alan","root","alan@qq.com"]
result2 = data.split('|', 1) # 切一个,遇到第一个切
result3 = data.rsplit('@') #
print(data) # "Alan|root|alan@qq.com"
print(result) # 输出 ["Alan","root","alan@qq.com"] 根据特定字符切开之后保存在列表中,方便以后的操作
10.3.9 字符串的拼接
python
data_list = ["Alan", "", "a", "huge","man"]
new_str = " ".join(data_list) # Alan is a huge man
print(new_str)
10.3.10 格式化字符串
python
address = "{0}市{1}区{2}街道"
data = address.format("上海","浦东新", "潍坊")
print(data) #上海市浦东新区潍坊街道
10.3.11 字符串转为字节类型
python
data = "苏东坡" # unicode,字符串类型
v1 = data.encode("utf-8") # utf-8,字节类型
v2 = data.encode("gbk") # gbk,字节类型
print(v1) # b'\xe8\x8b\x8f\xe4\xb8\x9c\xe5\x9d\xa1'
print(v2) # b'\xcb\xd5\xb6\xab\xc6\xc2'
s1 = v1.decode("utf-8") # 苏东坡
s2 = v2.decode("gbk") # 苏东坡
print(s1)
print(s2)
10.3.12 字符串内容居中、居左、居右显示
python
v1 = "王老汉"
# data = v1.center(21, "-")
# print(data) #---------王老汉---------
# data = v1.ljust(21, "-")
# print(data) # 王老汉------------------
# data = v1.rjust(21, "-")
# print(data) # ------------------王老汉
10.3.13 给字符串填充0
python
data = "alex"
v1 = data.zfill(10)
print(v1) # 000000alex
# 应用场景:处理二进制数据
data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"
10.3.14 公共功能
1、相加,字符串拼接
2、相乘,字符串 * 整数
3、长度
python
data = "zed"
print(len(data)) # 3
4、获取字符串中的字符,索引
python
message = "北京欢迎你"
print(message[0]) # 北
print(message[1]) # 京
print(message[2]) # 欢
字符串中是能通过索引取值,无法修改值;
5、获取字符串中的子序列,切片
python
message = "就像阳光穿破黑夜"
print(message[0:2]) # 就像
print(message[2:]) # 阳光穿破黑夜
print(message[:2]) # 就像
print(message[6:-1]) # 黑
print(message[6:len(message)]) # 黑夜
字符串切片自己读取数据,无法修改数据
6、步长,跳着取字符串的内容
py
name = "生活不是电影,生活比电影苦"
print( name[ 0:5:2 ] ) # 输出:生不电 【前两个值表示区间范围,最有一个值表示步长】
print( name[ :8:2 ] ) # 输出:生不电, 【区间范围的前面不写则表示起始范围为0开始】、
# print( name[ 2::2 ] ) # 输出:不电,活电苦
# print( name[ 2::3 ] ) # 输出:不影活影
print( name[ 2::3 ] ) # 输出:不电,活电苦 【区间范围的后面不写则表示结束范围为最后】
print( name[ ::2 ] ) # 输出:生不电,活电苦 【区间范围不写表示整个字符串】
print( name[ 8:1:-1 ] ) # 输出:活生,影电是不 【倒序】
7、循环
- while循环
pyth
message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
index = 0
while index < len(message):
print(message[index])
index += 1
- for循环
python
message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
for char in message:
print(char)
- range:帮助创建一系列数字
python
range(10) # [0,1,2,3,4,5,6,7,8,9]
range(1, 10) # [1,2,3,4,5,6,7,8,9]
range(1, 10, 2) #[1,3,5,7,9]
range(10, 1, -1) # [10,9,8,7,6,5,4,3,2]
- for + range:
python
for i in range(10)
print(i)
message = "休对故人思故国,且将新火试新茶,诗酒趁年华"
for i in range(5):
print(message[i])
####################
for i in range(len(message)):
print(message[i])
10.3.15 字符串类型转换
python
num = 999
data = str(num)
print(data) # "999"
10.3.16 字符串不可被修改
python
name = "Alan"
11.4 列表(list)
列表(list),是一个可变的容器,在里面可以存放多个不同类型的元素
11.4.1 定义
python
user_list = ["李白","苏轼","辛弃疾"]
number_list = [92,93,94,95]
data_list = [1,True,"Alan", "张楚岚"]
python
user_list = []
user_list.append("盖聂")
user_list.append(123)
user_list.append(False)
print(user_list) # ["盖聂",123,False]
不可变类型:字符串、布尔、整型
可变类型:列表
11.4.2 独有功能
1、追加,在原有列表中尾部追加值
python
data_list = []
data_list.append("s1")
data_list.append("s2")
2、批量追加,将一个列表中的元素逐一添加到另外一个列表
python
tools = ["板砖","菜刀"]
weapon = ["AK47","MP5"]
tools.extend(weapon)
print(tools)
3、插入,在原列表的指定索引位置插入值
python
user_list = ["李白","杜甫","白居易"]
user_list.insert(1,"王维") # ["李白","王维","杜甫","白居易"]
4、在原列表中根据值删除(从左到右找到第一个删除,慎用!里面没有会报错)
python
user_list = ["李白","苏轼","辛弃疾","孙笑川"]
if "孙笑川" in user_list:
user_list.remove("孙笑川")
print(user_list)
5、在原列表中根据索引删除某个元素(根据索引位置删除)
python
user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.pop(1) # 删除索引为1的元素
user_list.pop() #删除最后一个元素 ["李白","辛弃疾"]
item = user_list.pop()
6、清空原列表
python
user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.clear()
print(user_list) # []
7、根据值获取索引(从左到右找到第一个,慎用!找不到会报错)
python
user_list = ["李白","苏轼","辛弃疾","孙笑川"]
if "孙笑川" in user_list:
index = user_list.index("孙笑川")
print(index) # 3
8、列表元素排序
python
user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.sort()
print(user_list) # 默认从小到大排序
print(user_list.sort(reverse=True)) # 从大到小排序
# 注意:排序时内部元素无法进行比较时,程序会报错(尽量数据类型统一)
9、反转原列表
python
user_list = ["李白","苏轼","辛弃疾","孙笑川"]
user_list.reverse()
print(user_list) # 列表会反转
11.4.3 公共功能
1、相加,两个列表相加获取生成一个新的列表
python
data_list1 = ["李白","杜甫"]
data_list2 = ["苏轼","辛弃疾"]
data_list3 = data_list1 + data_list2
print(data_list3) # ["李白","杜甫","苏轼","辛弃疾"]
2、相乘(列表*整型,将列表中的元素再创建N份并生成一个新的列表)
python
data_list = ["李白","杜甫"] * 2
print(data_list) # ["李白","杜甫","李白","杜甫"]
3、运算符in包含
由于列表内部是由多个元素组成,可以通过in来判断元素是否在列表中
python
user_list = ["李白","杜甫","苏轼","白居易"]
result1 = "白居易" in user_list
result2 = "辛弃疾" in user_list
print(result1) # True
print(result2) # False
4、获取长度
python
user_list = ["李白","杜甫","苏轼","白居易"]
print(len(user_list)) # 4
5、索引
python
user_list = ["李白","杜甫","苏轼","白居易"]
print(user_list[3]) # 白居易
del user_list[0] #删除第0个元素
6、切片
py
# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )
python
# 改
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[0:2] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']
py
# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']
7、步长
python
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
# 0 1 2 3 4
print( user_list[1:4:2] ) # 刘华强 宋小宝
print( user_list[0::2] ) #
print( user_list[1::2] ) #
print( user_list[4:1:-1] ) # 刘能 宋小宝 尼古拉斯赵四
python
# 案例:实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)
data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)
# 给你一个字符串请实现字符串的翻转?
name = "12345"
name[::-1]
8、for循环
python
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
print(item)
python
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for index in range( len(user_list) ):
item = user_index[index]
print(item)
切记,循环的过程中对数据进行删除会踩坑
python
# 错误方式, 有坑,结果不是你想要的。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
if item.startswith("刘"):
user_list.remove(item)
print(user_list)
# 正确方式,倒着删除。
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
item = user_list[index]
if item.startswith("刘"):
user_list.remove(item)
print(user_list)
11.4.4 转换
- int、bool无法转换成列表
- 字符串转成列表没有意义;
py
name = "苏东坡"
list(name) # ["苏","东","坡"]
- 元组、集合转成list
python
v1 = (11,22,33,44)
vv1 = list(v1) # [11,22,33,44]
v2 = {"alex", "alan","otto"}
vv2 = list(v2) # ["alex", "alan", "otto"]
11.4.5 其他
嵌套
py
data = ["赵四",["1","2","3"],True, [11,22,[33,44]]]
11.5 元组(tuple)
列表(list):是一个有序且可变的容器,在里面可以存放多个不同类型的元素;
元组(tuple):是一个有序且不可变的容器,在里面可以存放多个不同类型的元素;
11.5.1 定义
python
v1 = (11,22,33)
v2 = ("小明","Alan")
v3 = (True,123,"Alex",[11,22,33])
# 建议:在元组的最后一个元素后面多加一个逗号,用来表示它是一个元组
v3 = ("Alan",11, )
11.5.5 公共功能
1、相加,两个列表相加获取一个新的元组
py
v1 = ("小明","小亮")
v2 = ("张三","李四")
v3 = v1 + v2
print(v3) # ("小明","小亮","张三","李四", )
2、相乘,列表*整型,将列表中的元素再创建N份
py
v1 = ("小明","小亮")
print(v1*2)
3、获取长度
python
user_tuple = ("小明","小亮","张三")
print(len(user_tuple)) # 3
4、索引
python
user_tuple = ("小明","小亮","张三")
print(user_tuple[1]) #小亮
5、切片
py
user_tuple = ("小明","小亮","张三")
print(user_tuple[0:2]) # 小明 销量
6、步长
py
user_tuple = ("小明","小亮","张三","李四","王五")
print(user_tuple[1:4:2])
print(user_tuple[4:1:-1])
# 反转tuple
new_user_tuple = user_tuple[::-1]
print(new_user_tuple)
7、for循环
python
user_tuple = ("小明","小亮","张三","李四","王五")
for item in user_tuple:
print(item)
for item in user_tuple:
if item == "张三":
continue
print(item)
目前,只有str、list、tuple可以被for循环
11.5.3 转换
其他类型转换为元组,使用tuple(其他类型)
,目前只有字符串和列表可以转换为元组
python
data = tuple(其他)
# str/list
11.5.4 嵌套
由于元组和列表都可以充当容器
,他们内部也可以放多个元组,并且也支持元素内的嵌套
12.6 set集合
set集合:无序、可变、不允许数据重复的容器
12.6.1 定义
python
v1 = {1,"22",True,"Alex"}
-
无序:无法通过索引定位值
-
可变:可以添加和删除元素
pythonv1 = {11,22,33} v1.add(44) print(v1) # {11,22,33,44}
-
不允许数据重复
pythonv1 = {11,22,33} v1.add(11) print(v1) # 11 22 33
什么时候用到集合:
想要维护一大堆不重复的数据的时候,就可以用它,比如:做爬虫去网上找图片链接时,为了避免数据重复,可以选择用集合去存储链接地址
注意:定义空集合时候,只能使用v=set{}
,不能使用v={}(这样定义是一个空字典)
12.6.2 独有功能
1、添加元素
python
data = {"苏东坡","白居易","辛弃疾"}
data.add("欧阳修")
print(data)
python
data = set()
data.add("周杰伦")
data.add("薛之谦")
print(data)
2、删除元素
python
data = {"苏东坡","白居易","辛弃疾","王富贵"}
data.discard("王富贵")
print(data)
3、交集
python
s1 = {"苏东坡","白居易","辛弃疾","王富贵"}
s2 = {"李白","杜甫","王勃","王富贵"}
s3 = s1 & s2 #取两个集合的交集
s4 = s1.intersection(s2) # 王富贵
print(s3,s4)
4、并集
python
s1 = {"苏东坡","白居易"}
s2 = {"李白","杜甫"}
s3 = s1 | s2
s4 = s1.union(s2)
print(s3,s4)
5、差集
python
s1 = {"刘能","赵四","皮常山"}
s2 = {"刘科长","赵市长","皮常山"}
s3 = s1 - s2 #取差集,s1中有且s2中没有的值
s3 = s1.difference(s2) #取差集,s1中有且s2中没有的值
12.6.3 公共功能
1、减,计算差集
2、&,取交集
3、|,计算并集
4、长度
python
v1 = {"张三","李四","王五"}
data = len(v1)
print(data)
5、for循环
python
v1 = {"张三","李四","王五"}
for item in v1:
print(item)
12.6.4 转换
其他类型如果想转换成集合类型,使用
set(其他类型)
,如果数据有重复会自动删除
注意: int/list/tuple/dict都可以转换为集合
12.6.5 其他
12.6.5.1 集合的存储原理
12.6.5.2 元素必须可哈希
因存储原理,集合的元素必须是可哈希的值,即:内部通过通过哈希函数把值转换成一个数字。
目前可哈希的数据类型:int、bool、str、tuple,而list、set是不可哈希的。
总结:集合的元素只能是 int、bool、str、tuple 。
-
转换成功
pythonv1 = [11,22,33,11,3,99,22] v2 = set(v1) print(v2) # {11,22,33,3,99}
-
转换失败
pythonv1 = [11,22,["alex","eric"],33] v2 = set(v1) # 报错 print(v2)
12.6.5.3 查找速度特别快
python
user_set = {"苏东坡","alex","李璐"}
if "alex" in user_set:
print("在")
else:
print("不在")
12.6.5.4 对比和嵌套
类型 | 是否可变 | 是否有序 | 元素要求 | 是否可哈希 | 转换 | 定义空 |
---|---|---|---|---|---|---|
list | 是 | 是 | 无 | 否 | list(其他) | v=[]或v=list() |
tuple | 否 | 是 | 无 | 是 | tuple(其他) | v=()或v=tuple() |
set | 是 | 否 | 可哈希 | 否 | set(其他) | v=set() |
注意:由于True和False本质上存储的是 1 和 0 ,而集合又不允许重复,所以在整数 0、1和False、True出现在集合中会有如下现象:
python
v1 = {True, 1}
print(v1) # {True}
v2 = {1, True}
print(v2) # {1}
v3 = {0, False}
print(v3) # {0}
v4 = {False, 0}
print(v4) # {False}
None类型
Python中有一个特殊的值None类型,表示为空
目前可以转换为False的值有:
python
0
""
[] or list()
() or tuple()
set()
None
12.7 dict字典类型
字典是无序、键不重复且元素只能是键值对的可变的容器
-
容器
-
元素必须是键值对
-
键不重复,重复则会被覆盖
pythondata = {"k1": 1, "k1": 2} print(data) # {"k1": 2}
-
无序(python3.6+之后字典就是有序了,之前字典是无序的)
12.7.1 定义
python
d1 = {}
d2 = dict()
python
info = {
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
字典中对键值对的要求:
- 键: 必须是可哈希的,目前是: int/bool/str/tuple,不可哈希的类型:list/set/dict;
- 值:任意类型;
12.7.2 独有功能
1、获取值
python
info = {
"name": "Alan"
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
age = info.get("age")
print(age)
name = info.get("name")
print(name)
address = info.get("address")
print(address) # None
birth = info.get("birth", "2001-01-28")
print(birth) # 2001-01-28
python
# 案例
user_list = {
"alex": "123",
"admin": "123456"
}
username = input("请输入用户名: ")
password = input("请输入密码: ")
pwd = user_list.get(username)
if pwd == None:
print("用户名不存在")
else:
if pwd == password:
print("登录成功")
else:
print("密码错误")
# 写代码的准则:简单的逻辑放在前面,复杂的逻辑放在后面
2、获取所有的键
python
info = {
"name": "Alan"
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
data = info.keys()
print(data) # 输出(["name","age","sex","status","hobby"]) 高仿列表
print(list(data))
注意:在python2中字典.keys()
直接获取到的是列表,而python3中返回的是高仿列表,高仿列表可以被循环显示
python
for key in info.keys():
print(key)
# 判断某个key是否存在字典中
if "age" in info.keys():
print("age是字典的键")
3、获取所有的值
python
info = {
"name": "Alan"
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
data = info.values()
print(data) # dict_value(["Alan",12,"male","True",["游戏",读书]])
注意:在python2中字典.values()
直接获取到的是列表,而python3中返回的是高仿列表,高仿列表可以被循环显示
python
for value in info.values():
print(value)
if 12 in info.values():
print("12是字典的值")
4、获取所有的键值
python
info = {
"name": "Alan"
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
data = info.items()
print(data) # 输出dict_items() ([('age', 12),("name",Alan),....])
python
for item in info.items():
print(item) #item是一个元组
print(item[0],item[1])
# -------------------
for key,value in info.items():
print(key,value) #key代表键,value代表值
5、设置值
python
info = {
"name": "Alan"
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
# 没有这个键值是添加,有这个键的话是修改
data.setdefault("salary","15000")
6、批量更新键值对
python
info = {
"name": "Alan"
"age": 12,
"sex": "male",
"status": True,
"hobby": ["游戏", "读书"]
}
info.update({"age": 18, "name": "Bob"})
print(info) # info中没有的键则直接添加,有的键则是更新值,主打一个批量更新
7、指定移除键值对
python
info = {"age": 12, "status": True, "name": "Alex"}
data = info.pop("age")
print(info) # {"status": True, "name": "Alex"}
print(data) # 12
8、按照顺序移除(后进先出)
python
info = {"age": 12, "status": True, "name": "Alex"}
data = info.popitem()
print(info) # {"age": 12, "status": True}
print(data) # {"name": "Alex"}
python
# 练习题
"""
结合下面的两个变量 header 和 stock_dict实现注意输出股票信息,格式如下:
SH601778,股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
SH688566,股票名称:吉贝尔、当前价:... 。
...
"""
header = ['股票名称', '当前价', '涨跌额']
stock_dict = {
'SH601778': ['中国晶科', '6.29', '+1.92'],
'SH688566': ['吉贝尔', '52.66', '+6.96'],
'SH688268': ['华特气体', '88.80', '+11.72'],
'SH600734': ['实达集团', '2.60', '+0.24']
}
for key,value in stock_dict.items():
# 'SH601778', ['中国晶科', '6.29', '+1.92']
textList = list()
for index in range(len(header)):
str = "{0}: {1}".format(header[index],value[index])
textList.append(str)
print("{0}, {1}".format(key, ", ".join(textList)))
12.7.3 公共功能
1、求并集(python3.9加入)
python
v1 = {"k1": 1, "k2": 2}
v2 = {"k2": 22, "k3": 33}
v3 = v1 | v2
print(v3) # {"k1": 1, "k2": 22, "k3": 33}
2、长度
python
info = {"age": 12, "status": True, "name": "Alex"}
print(len(info)) # 3
3、是否包含
python
info = {"age": 12, "status": True, "name": "Alex"}
v1 = "age" in info
print(v1) # true
v2 = "age" in info.keys()
4、索引(键)
字典区别于元组和列表,字典的索引是键,而列表和元组则是0 1 2
python
info = {"age": 12, "status": True, "name": "Alex"}
print(info["age"]) # 输出12
print(info["staus"]) # 输出True
print(info["xxx"]) # 报错
# 建议使用 info.get("key")
5、根据键修改值和添加值和删除键值对
python
info = {"age": 12, "status": True, "name": "Alex"}
info["gender"] = "男"
print(info) #{"age": 12, "status": True, "name": "Alex","gender": "男"}
python
info = {"age": 12, "status": True, "name": "Alex"}
del info["age"] # 保证键存在,才能删除
print(info) # {"status": True, "name": "Alex"}
6、for循环
python
info = {"age": 12, "status": True, "name": "Alex"}
for key in info.keys():
print(key)
for value in info.values():
print(value)
for key,value in info.items():
print(key, value)
12.7.4 转换
想要转换为字典.
python
v = dict( [ ("k1", "v1"), ["k2", "v2"] ] )
print(v) # { "k1":"v1", "k2":"v2" }
python
info = { "age":12, "status":True, "name":"武沛齐" }
v1 = list(info) # ["age","status","name"]
v2 = list(info.keys()) # ["age","status","name"]
v3 = list(info.values()) # [12,True,"武沛齐"]
v4 = list(info.items()) # [ ("age",12), ("status",True), ("name","武沛齐") ]
12.7.5 其他
12.7.5.1 存储原理
12.7.5.2 速度快
python
info = {
"alex":["肝胆","铁锤"],
"老男孩":["二蛋","缺货"]
}
for "alex" in info:
print("在")
python
info = {
"alex":["肝胆","铁锤"],
"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2 = info.get("alex")
12.7.6 嵌套
我们已学了很多数据类型,在涉及多种数据类型之间的嵌套时,需注意一下几点:
-
字典的键必须可哈希(list/set/dict不可哈希)。
pythoninfo = { (11,22):123 } # 错误 info = { (11,[11,22,],22):"alex" }
-
字典的值可以是任意类型。
pythoninfo = { "k1":{12,3,5}, "k2":{"xx":"x1"} }
-
字典的键和集合的元素在遇到 布尔值 和 1、0 时,需注意重复的情况。
-
元组的元素不可以被替换。
python
dic = {
'name':'汪峰',
'age':48,
'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],
'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字
d1 = dic['wife'][0]['name']
print(d1)
2. 获取汪峰的孩子们
d2 = dic['children']
print(d2)
3. 获取汪峰的第一个孩子
d3 = dic['children'][0]
print(d3)
4. 汪峰的媳妇姓名变更为 章子怡
dic['wife'][0]['name] = "章子怡"
print(dic)
5. 汪峰再娶一任妻子
dic['wife'].append( {"name":"铁锤","age":19} )
print(dic)
6. 给汪峰添加一个爱好:吹牛逼
dic['hobby'] = "吹牛逼"
print(dic)
7. 删除汪峰的年龄
del dic['age']
或
dic.pop('age')
print(dic)
"""
12.8 float浮点型
python
v1 = 3.14
v2 = 9.99
- 在类型转换时,浮点型转为整型,会将小数部分去掉
python
v1 = 3.4
print(int(v1)) # 3
- 保留小数点后N位
python
v1 = 3.1415926
print(round(v1, 3)) # 3.142
-
浮点型的坑
python
import decimal
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3