python学习笔记（4）
循环
1.for循环
for xx in xxx
# 1.range 只给stop 值 区间为 [0,stop) #都是左闭右开
for i in range(10):
print(i)
#2.区间 [start,stop)
for i in range(11, 15):
print(i)
# 区间 [start,stop) 步长是2
for i in range(20, 30, 2):
print(i)
#结果
0 1 2 3 4 5 6 7 8 9
11 12 13 14
20 22 24 26 28
还可以循环 iterable 序列： 可迭代
name = 'yangmi'
len(name)
for i in range(len(name)):
print(name[i])
#结果
y
a
n
g
m
i
2.while循环
只要条件满足，就不断循环，条件不满足时退出循环。
比如要计算100以内所有偶数之和，可以用while循环实现：
# while condition:
# 代码块
i = 0
summ = 0
while i <= 100:
summ += i
i += 2
print(summ)
#结果
2550
flag = True 方法：标记位 只有满足这个条件才会调出死循环。
age = 23
flag = True
while flag:
if age > 20:
flag = False
break 强制终止循环 continue 跳出本次循环
n = 0
summ = 0
while n <= 100:
# 只计算十以内的偶数和
if n > 10:
break
summ += n
n += 2
print(summ)
#结果
30
# 10以内的乘积 但是不乘8
n = 1
summ = 1
while n < 10:
n += 1
if n == 8:
continue
summ *= n
print(summ)
#结果
453600
实例：
检查大小写字母： 使用标记位：
s = 'beautifulcodE'
i = 0
vol_len = len(s)
flag = True
while i < vol_len:
if s[i].isupper():
print(s[i])
flag = False
break
i += 1
if flag:
print("无大写字母")
#结果
E
3.for else
for else 循环正常跑完 就会执行else中的内容
如果break执行了 就不会执行else中的内容
# for else 检测2，n素数
for i in range(2, 10):
for j in range(2, i):
if i % j == 0:
print(f"{i} is not a prime number")
print(f"{i} = {j} * {i / j}")
break
else:
print(f"{i} is a prime number")
#结果
2 is a prime number
3 is a prime number
4 is not a prime number
4 = 2 * 2.0
5 is a prime number
6 is not a prime number
6 = 2 * 3.0
7 is a prime number
8 is not a prime number
8 = 2 * 4.0
9 is not a prime number
9 = 3 * 3.0
数据容器
1.list
list列表是一种有序的集合，可以随时添加和删除其中的元素。 关键字：‘有序’，‘可变’。
同一个列表中尽量保持数据类型相同。
list_a = [1, 0, 1.0, 1.2, -0.0, "a", "b", "1", True, False] # 列表一般是这种形式
print(len(list_a))
print(list_a[-1])
print(list_a[::-1])
#结果
10
False
[False, True, '1', 'b', 'a', -0.0, 1.2, 1.0, 0, 1]
list方法
list列表可以进行一系列序列操作:如索引、 切片、增加、删除、修改、查询元素等.
list_a = [1, 0, 1.0, 1.2, -0.0, "a", "b", "1", True, False]
# 增
# append 追加是直接追加内容 不做处理
list_a.append("帅哥")
print(list_a)
list_a.append(["美女"])
print(list_a)
# 结果
[1, 0, 1.0, 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥']
[1, 0, 1.0, 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥', ['美女']]
# insert 指定索引位置增加 在中间插入
list_a.insert(3, ["靓仔"])
print(list_a)
#结果
[1, 0, 1.0, ['靓仔'], 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥', ['美女']]
# extend 将可迭代的数据 单个放进去 相当于循环append
list_a.extend("ab")
list_a.extend(["AB"])
print(list_a)
#结果
[1, 0, 1.0, ['靓仔'], 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥', ['美女'], 'a', 'b', 'AB']
# 删除
# pop 弹出 默认弹出最后一个元素 但可以给具体位置
list_a.pop(-2)
print(list_a)
#结果
[1, 0, 1.0, ['靓仔'], 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥', ['美女'], 'a', 'AB']
# remove 指定元素删除
list_a.remove(1)
print(list_a)
#结果
[0, 1.0, ['靓仔'], 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥', ['美女'], 'a', 'AB']
# 清空所有元素
list_a.clear()
print(list_a)
# 改
# 直接查找元素 然后赋值
list_a[0] = 0.01
print(list_a)
#结果
[0.01, 0, 1.0, ['靓仔'], 1.2, -0.0, 'a', 'b', '1', True, False, '帅哥', ['美女'], 'a', 'AB']
# 查
# index 查找值的索引位置
print(list_a.index(1.2))
#结果
4
print(list_a.count(1))
2
#reverse 用于列表中数据的反转
list_a.reverse()
print(list_a)
#结果
['AB', 'a', ['美女'], '帅哥', False, True, '1', 'b', 'a', -0.0, 1.2, ['靓仔'], 1.0, 0, 0.01]
#sort函数 用于对列表中数据的排序 从小到大
num_list = [1, 2, 5, 6, 8, 3, 5, 7]
num_list.sort()
print(num_list)
#结果
[1, 2, 3, 5, 5, 6, 7, 8]
下面介绍一种用于列表中的排序方法：
冒泡排序：通过对待排序序列从前向后（从下标较小的元素开始），依从对相邻两个元素的值进行两两比较，若发现逆序则交换，使值较大的元素逐渐从前移向后部。
s = [1, 3, 5, 7, 6, 8]
for i in range(len(s) - 1):
# 循环没有排好序的数据
flag = True
for j in range(len(s) - 1 - i):
if s[j] > s[j + 1]:
# tmp = s[j]
# s[j] = s[j+1]
# s[j+1] = tmp
flag = False
s[j], s[j + 1] = s[j + 1], s[j]
if flag:
break
print(s)
#结果
[1, 3, 5, 6, 7, 8]
listcopy
# copy
l1 = ['a', 'b', 'c', 'd', [1, 2]]
l2 = l1
print(l1)
print(l2)
l1.append("e")
print(l1)
print(l2)
#结果
['a', 'b', 'c', 'd', [1, 2]]
['a', 'b', 'c', 'd', [1, 2]]
['a', 'b', 'c', 'd', [1, 2], 'e']
['a', 'b', 'c', 'd', [1, 2], 'e']
浅拷贝
只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存（分支）。
- 浅拷贝是按位拷贝对象，它会创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。
- 如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用类型），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。
# 浅拷贝
l2 = l1.copy()
print(l1)
print(l2)
l1.append("f")
print(l1)
print(l2) #l2不会改变 没有改变内存
['a', 'b', 'c', 'd', [1, 2], 'e']
['a', 'b', 'c', 'd', [1, 2], 'e']
['a', 'b', 'c', 'd', [1, 2], 'e', 'f']
['a', 'b', 'c', 'd', [1, 2], 'e']
l1[4].append(3) #改变了内存 所以l2也改变了
print(l1)
print(l2)
#结果
['a', 'b', 'c', 'd', [1, 2, 3], 'e', 'f']
['a', 'b', 'c', 'd', [1, 2, 3], 'e']
深拷贝
会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象，是“值”而不是“引用”（不是分支）
- 拷贝第一层级的对象属性或数组元素
- 递归拷贝所有层级的对象属性和数组元素
- 深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。
# 深拷贝
import copy #不会改变
l2 = copy.deepcopy(l1)
l1.append('g')
l1[4].append(4)
print(l1)
print(l2)
#结果
['a', 'b', 'c', 'd', [1, 2, 3, 4], 'e', 'f', 'g']
['a', 'b', 'c', 'd', [1, 2, 3], 'e', 'f']
列表转字符串
join方法把一个可迭代的内容转换成字符串 在中间加上你想加的内容，可迭代的内的数据类型应该为字符串
li_a = ['亚索', '妖姬', '塞拉斯', '艾克', '盲僧']
print("".join(li_a))
#结果
亚索妖姬塞拉斯艾克盲僧
stra = '123456789'
print("|".join(stra))
#结果
1|2|3|4|5|6|7|8|9
补充知识点： 列表在循环的时候不要去做删除的事情。
列表生成式
一般都是空列表append的时候使用这个方式
li = []
for i in range(1, 11):
if i % 2 == 0:
li.append(f'{i} * {i}')
print(li)
print([f'{i} * {i}' for i in range(1, 11) if i % 2 == 0]) #列表生成式
# 三元运算符 True if else False
a = 5
if a % 5 == 0:
print(1)
else:
print(0)
print(1) if a % 5 == 0 else print(0)
2.tuple
有序列表 不可变
因为不可变，所以使用的方法很少
tuple的使用可以使得代码更安全，防止错误赋值导致重要对象的改变。
tuple_a = ("a", 1, True, None)
print(tuple_a[0])
#结果
a
tuple_b = ([1, 2], (3, 4), 'a') #元组中的列表可以改变 注意
print(tuple_b)
tuple_b[0].append(3)
print(tuple_b)
#结果
([1, 2], (3, 4), 'a')
([1, 2, 3], (3, 4), 'a')
定义一个一元组：
# 定义一个一元组
tuple_1 = ("a",)
print(tuple_1, type(tuple_1))
元组中同样也有join方法：
tuple_a = ('亚索', '妖姬', '塞拉斯', '艾克', '盲僧')
print("".join(tuple_a))
3.dict
字典 ： 1.无序 2.key不可变 3.字典可变
1.dict方法
dict_score = {"m": 95, 'b': 75, 't': 85, 0: 333}
print(dict_score[0]) #按照key找v
#结果
333
print(dict_score.pop(0))
print(dict_score) #随机弹出（删除）一个值 v 但是如果给他相应的k就会弹出（删除）相应的v 返回被删除的值
#结果
333
{'m': 95, 'b': 75, 't': 85}
# get 通过key去取值 如果key不存在则返回none 最好使用get方法去获取值
print(dict_score.get("s"))
#结果
None
# fromkeys 通过可迭代数据形成一个字典
print(dict_score.fromkeys("ab", 1))
#结果
{'a': 1, 'b': 1}
#Python 字典items() 函数以列表返回可遍历的(键, 值) 元组数组。
print(dict_score.items())
#结果
dict_items([('m', 95), ('b', 75), ('t', 85)])
#字典如果有重复的键 ，值一般以后面的为准 相当于后来的值覆盖了前面的值
dic_a = {1: 2, True: 3, 2: 3, 2: "3"}
# 字典的新增 直接给一个从来没有出现过的键 然后给一个值
# 如果是已经存在的key则覆盖之前的值
dic_a[4] = "4"
print(dic_a)
# isinstance 检测某个值是否为那个对象
dic_a = {
"a": (1.2, 2.2),
"b": [3, 4],
"c": {5: 6, 7: 8},
"d": 9
}
for k, v in dic_a.items():
if isinstance(v, dict):
for k1, v1 in v.items():
print(v1)
#结果
6
8
2.DictJson
dict与json之间的转化：
import json
# dict 与 json之间的转换
dict_a = {"1": 2, "3": 4}
print(dict_a)
# 字典转换为json
json_str = json.dumps(dict_a) #dumps
print(json_str, type(json_str))
# json大字符串转字典
json_dict = json.loads(json_str) #loads
print(json_dict,type(json_dict))
#结果
{'1': 2, '3': 4}
{"1": 2, "3": 4} <class 'str'>
{'1': 2, '3': 4} <class 'dict'>
3.字典生成式
# 字典生产式
dic_a = {}
for i in "ABC":
dic_a[i] = i.lower()
print(dic_a)
print({i: i.lower() for i in "ABC"}) #字典生成式 注意 :
4.dict补充
# 字典循环的时候也不要去做删除的事情 字典直接就报错了
dic_a = {"a": "b", "c": "d", "e": "f"}
for k, v in dic_a.items():
print(k, v)
dic_a.pop(k)
4.set
集合 相当于只存储了字典中的键 只是没有值，依然遵循键的规则
不可变 不重复
set_a = {1, 2, "True", True, 1.0, ("c", "d")}
print(set_a)
#结果
{1, 2, ('c', 'd'), 'True'}
一般用于去重：
list_a = ['a', 'b', "c", "d", "a"]
print(list(set(list_a))) #输出的位置随机
tuple_a = (1, 2, 3, 2)
print(tuple(set(tuple_a)))
#结果
['d', 'a', 'c', 'b']
(1, 2, 3)
创建一个空集合：
# 创建一个空的集合
# 只有一个大括号会被识别成字典
set_b = {}
set_c = set()
print(type(set_b))
#结果
<class 'dict'>
1.set方法
set_num1 = {1, 2, 3, 4, 5, 6, 7}
set_num2 = {4, 5, 6, 7, 8, 9}
set_num3 = {4, 5, 6, 7}
# pop 弹出一个键 随机
set_num1.pop()
print(set_num1)
#结果
{2, 3, 4, 5, 6, 7}
# remove 删除一个键 如果没有这个键就会报错
# set_num1.remove(8)
# print(set_num1)
# discard 删除一个键 如果没有这个键删除不会报错
set_num1.discard(8)
print(set_num1)
#结果
{2, 3, 4, 5, 6, 7}
# add 添加一个新键
# 如果键已存在 则相当于没有添加
set_num1.add(8)
print(set_num1)
#结果
{2, 3, 4, 5, 6, 7, 8}
set_num1 = {1, 2, 3, 4, 5, 6, 7}
# difference 去除原集合中和集合2中相同的部分
print(set_num1.difference(set_num2))
# difference_update 从这个集合中删除和另外一个集合中相同的元素 在原集合上操作
# set_num1.difference_update(set_num2)
print(set_num1)
#结果
{1, 2, 3}
{1, 2, 3, 4, 5, 6, 7}
# intersection 交集
print(set_num1.intersection(set_num2))
#结果
{4, 5, 6, 7}
# union 并集
print(set_num1.union(set_num2))
#结果
{1, 2, 3, 4, 5, 6, 7, 8, 9}
# symmetric_difference 并集 - 交集
print(set_num1.symmetric_difference(set_num2))
#结果
{1, 2, 3, 8, 9}
# isdisjoint 检测两个集合是否具有相同的元素
print(set_num1.isdisjoint({8, 9}))
#结果
True
# issubset issuperset 检测是否为子集或者父集
print(set_num1.issuperset(set_num3))
#结果
True
遍历数据容器
1.遍历list
list_a = ["a", "b", "c", "d", "e", "f"]
# 直接遍历内部值
for i in list_a:
print(i)
#结果
a
b
c
d
e
f
# 遍历索引
for i in range(len(list_a)):
print(list_a[i])
#结果
a
b
c
d
e
f
for ind, val in enumerate(list_a): #enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
print(ind, val)
#结果
0 a
1 b
2 c
3 d
4 e
5 f
2.遍历tuple
tuple_a = ("h", "i", "j", "k", "l", "m", "n")
for i in tuple_a:
print(i, end="\t")
#结果
h i j k l m n
for i in range(len(tuple_a)):
print(tuple_a[i], end="\t")
#结果
h i j k l m n
for ind, val in enumerate(tuple_a):
print(ind, val, end="\t")
#结果
0 h 1 i 2 j 3 k 4 l 5 m 6 n
3.同时遍历list和tuple
list_a = ["a", "b", "c", "d", "e", "f"]
tuple_a = ("h", "i", "j", "k", "l", "m", "n")
for i, j in zip(list_a, tuple_a):
print(i, j)
#结果
a h
b i
c j
d k
e l
f m
4.遍历dict
dict_score = {"m": 95, 'b': 75, 't': 85}
#字典的遍历方式
for k, v in dict_score.items():
print(k, v)
#结果
m 95
b 75
t 85
print(dict_score.keys()) #单独查看键
print(dict_score.values()) #单独查看值
#结果
dict_keys(['m', 'b', 't'])
dict_values([95, 75, 85])
#字典 popitem() 方法随机返回并删除字典中的最后一对键和值。
dict_score.popitem()
print(dict_score)
#结果
{'m': 95, 'b': 75}
# in
dict_b = {"n": "m"}
if "m" in dict_b.keys(): #m不是key
print("yes")
#结果
6674
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
