首页 > 编程语言> > 我的python学习之路-基础2

我的python学习之路-基础2

2020-11-28 12:31:41 作者：互联网

本文内容：

流程控制
字符串的格式化 format
列表、元组的操作
列表、元组的相关方法
字典的相关函数
集合相关的操作

一、流程控制

　　　　分为三种：1、顺序结构 2、分支结构 3、循环结构

1、顺序结构

　　默认代码从上到下依次执行

2、分支结构

　　1、单分支结构　

study_bug = "xx"
if study_bug == "xx":
    print("你的年薪最高")

　　2、双分支结构

goodman = "xx"
if goodman == "xx":
    print("勤工俭学")
else:
    print("好吃懒做")

　　3、多分支结构　　

 1 youqian = False
 2 youfang = False
 3 youche = False
 4 youyanzhi = True
 5 youtili = True
 6 
 7 if youqian == True:
 8     print("老娘要嫁给你1")
 9 elif youfang == True:
10     print("老娘要嫁给你2")
11 elif youche == True:
12     print("老娘要嫁给你3")
13 elif youyanzhi == True:
14     print("老娘要嫁给你4")
15 elif youtili == True:
16     print("老娘要嫁给你5")
17 else:
18     print("你是个好人..")

View Code

　　4、巢状分支

单项分支,双向分支,多项分支的互相嵌套的一种语法

 1 youqian = True
 2 youfang = True
 3 youche = False
 4 youyanzhi = True
 5 youtili = False
 6 
 7 if youqian == True:
 8     if youfang == True:
 9         if youche == True:
10             if youyanzhi == True:
11                 if youtili == True:
12                     print("别想跑了,老娘要定了...")
13                 else:
14                     print("上道边,重金求子")
15             else:
16                 print("请你去泰国整容...")
17         else:
18             print("你去买了布加迪威航")
19 else:
20     print("你是个好人 .. ")

View Code

3、循环结构

特点: 减少冗余代码,提升代码效率，while for 两种循环、

1、while 循环

# 打印1 ~ 100
# 第一步
i = 1
# 第二步
while i <= 100:
    # 第四步
    print(i)
    
    # 第三步
    i += 1 # i = i + 1

2. for循环

　　适用于可迭代性数据(Iterable)(容器类型数据,range对象,迭代器)

# 遍历字符串
container = "王寅要加油"
# 遍历列表
container = ["王生福","敬旭阳","熊海瑞","梁瑞卿"]
# 遍历元组
container = ("王生福","敬旭阳","熊海瑞","梁瑞卿")
# 遍历集合
container = {"王生福","敬旭阳","熊海瑞","梁瑞卿"}
# 遍历字典 (遍历数据时,默认遍历的是字典的键)
container = {"wsf":"王生福","jxy":"敬旭阳","xhr":"小黄人"}

for i in container:
    print(i)

# 遍历不等长的二级容器
container = [("杨特","白金鸽","郝建康"),["吕菲菲","王寅"],{"赵沈阳"}]
for i in container:
    for j in i :
        print(j)

# 遍历等长的二级容器,采用变量解包的方式
container = [("马保国","马户","马累"),["王健林","王思聪","王寅"],("马云","马化腾","马伊琍")]
for a,b,c in container:
    print(a,b,c)

2.1 range的三种用法对象 (留头舍尾)

1.range( start , end , step )

　　 for i in range(1,10,3): # 1 4 7 print(i)

　2. range( start , end )

　　 for i in range(3,7): # 3 4 5 6 print(i)

　3.range(end) 从0开始,留头舍尾

for i in range(3):print(i)

3、pass、break、continue 关键字的应用

1）、pass 用作来占位

if 5 == 5:
    pass
    
while True:
    pass

2）、break 终止当前循环 (只能应用在循环之中)

i = 1
while i <= 10 :
    print(i)
    if i == 5 :
        break
    i += 1

3）、continue 跳过当前循环,从下一次循环开始 (只能应用在循环之中)

for i in range(1,11):
    if i == 5:
        continue
    print(i)

二、字符串的格式化 format

1、顺序传参

1 strvar = "{}向{}开了一枪,饮蛋而亡".format("王寅","菲菲")
2 print(strvar) # 王寅向菲菲开了一枪,饮蛋而亡

2、索引传参

1 strvar = "{1}向{0}开了一枪,饮蛋而亡".format("王寅","菲菲")
2 print(strvar) #菲菲向王寅开了一枪,饮蛋而亡

3、关键字传参

strvar = "{who1}从后面掏了{who2}一下,回头一记天马流星拳".format(who1="王寅",who2="方进顺")
print(strvar) #王寅从后面掏了方进顺一下,回头一记天马流星拳

4、容器类型数据传参

1 strvar = "{0[1]}亲了{1[0]}一下,鼻血直冒三万多尺".format(["王钊","郝建康"],("荷叶","王永捐"))
2 strvar = "{group2[1]}亲了{group1[1]}一下,鼻血直冒三万多尺".format(group1=["王钊","郝建康"],group2 = ("荷叶","王永捐"))
3 # group2[yj] 如果是字典在format格式化字符串的使用中,不能加上引号""
4 strvar = "{group2[yj]}亲了{group1[0]}一下,鼻血直冒三万多尺".format(group1=["王钊","郝建康"],group2 = {"wz":"王兆","yj":"永捐"})
5 print(strvar)

5、format 填充符号的使用

^ :原字符串居中
< :原字符串居左
> :原字符串居右

who:*^10
* :要填充的符号
^ :原字符串居中
10: 填充的字符串 +原字符串

strvar="{who:*^7}在在{where:->6}坐着,看风景,感觉{feel:!<10}" .format(who="小明",where="阳台",feel="高兴")
strvar="{0:*^7}在在{1:->6}坐着,看风景,感觉{1:!<10}" .format("小明","阳台","高兴")
print(strvar) 
# **小明***在在----阳台坐着,看风景,感觉阳台!!!!!!!!

6、进制转换等特殊符号的使用(:d :s :f)

（1）:d 整型占位符 :2d 占三位

1 strvar= "小明买了{:<2d}个苹果" .format(5)
2 print(strvar) #小明买了5 个苹果

（2）:f 浮点型占位符 (必须是浮点型) 默认小数点保留六位

1 strvar = "于盛林毕业了,一个月工资:{:f}".format(9.91234567)
2 # :.2f 小数点保留两位 存在四舍五入
3 strvar = "于盛林毕业了,一个月工资:{:.2f}".format(9.91934567)
4 print(strvar) #于盛林毕业了,一个月工资:9.92

（3）:s 字符串占位符 (必须是字符串)

1 strvar = "{:s}".format("欢庆真胖~")
2 print(strvar) #欢庆真胖~

（4）:, 金钱占位符

1 strvar = "{:,}".format(12345678)
2 print(strvar) #12,345,678

三、列表、元组的操作

1.列表的拼接 (同元组)

lst1 = ["梁新宇","孟凡伟"]
lst2 = ["孙接口","王永捐"]
res = lst1 + lst2
print(res) #['梁新宇', '孟凡伟', '孙接口', '王永捐']

2.列表的重复（同元组）

lst1 = ["梁新宇","孟凡伟"]
res = lst1 * 3
print(res) #['梁新宇', '孟凡伟', '梁新宇', '孟凡伟', '梁新宇', '孟凡伟']

3、列表的切片（同元组）

 1 lst = ["曹培显","欢庆","刘玉波","耿择时","家营和","黄常见","刘灵镇","孙翔宇"]
 2 # (1)[开始索引:]  从开始索引截取到列表的最后
 3 res = lst[2:]
 4 print(res) #['刘玉波', '耿择时', '家营和', '黄常见', '刘灵镇', '孙翔宇']
 5 # (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
 6 res = lst[:7]
 7 print(res) #['曹培显', '欢庆', '刘玉波', '耿择时', '家营和', '黄常见', '刘灵镇']
 8 # (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
 9 res = lst[3:5]
10 print(res) #['耿择时', '家营和']
11 # (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
12 # 从左到右 正向截取
13 res = lst[::3]
14 print(res) #['曹培显', '耿择时', '刘灵镇']
15 # 从右向左 逆向截取
16 res = lst[::-1]
17 print(res) #['孙翔宇', '刘灵镇', '黄常见', '家营和', '耿择时', '刘玉波', '欢庆', '曹培显']

View Code

4、列表的获取 (同元组)

1 res = lst[1]
2 print(res) #欢庆

5、列表的修改( 可切片 )

1）、一次修改一个

1 lst=[1,2,3,4,5,6,7,8]
2 lst[0]="a"
3 print(lst) # ['a', 2, 3, 4, 5, 6, 7, 8]

2）、一次修改多个 ,等号右边必须是Iterable(容器类型的数据 range对象迭代器)

1 lst=[1,2,3,4,5,6,7,8]
2 lst[1:3]="abc"
3 print(lst) #1, 'a', 'b', 'c', 4, 5, 6, 7, 8]

3）、一次修改多个(带步长) 截取几个,修改几个

1 lst=[1,2,3,4,5,6,7,8]
2 lst[::3]=["a","b","c"]
3 print(lst) #['a', 2, 3, 'b', 5, 6, 'c', 8]

5、列表的删除（可切片）

1）、一次删除一个

1 lst=[1,2,3,4,5,6,7,8]
2 del lst[0]
3 print(lst) #[2, 3, 4, 5, 6, 7, 8]

2）、一次删除多个

lst=[1,2,3,4,5,6,7,8]
del lst[0:2]
print(lst) # [3, 4, 5, 6, 7, 8]

3）、注意点 (改写法删除的是res 变量,不是列表)

lst=[1,2,3,4,5,6,7,8]
res= lst[0:2]
del res
print(lst) #[1,2,3,4,5,6,7,8]

四、列表、元组的相关方法

1、增加

1、append 向列表的末尾添加新的元素

lst = [1]
lst.append(2)
print(lst) # [1, 2]

2、insert 在指定索引之前插入元素

1 lst=[1,2]
2 lst.insert(0,3)
3 print(lst) #[3, 1, 2]

3、extend 迭代追加所有元素

必须是Iterable这样的可迭代性数据（容器类型数据、range对象、迭代器）

1 lst1=[4,5]
2 lst1="abc"
3 lst.extend(lst1)
4 print(lst) #[3, 1, 2, 'a', 'b', 'c']

2、删除

1、pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)

1 lst = [1,2,3,4,5,5]
2 lst.pop(2)
3 print(lst) # [1,2,4,5,5]

2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个

lst = [1,2,3,4,5,5]
lst.remove(5)
print(lst) #[1,2,3,4,5]

3.clear 清空列表

1 lst.clear()
2 print(lst) #[]

3、其他操作

1、index 获取某个值在列表中的索引

1 lst = [1,2,3,4,5,5]
2 res = lst.index(5)
3 # res = lst.index(6) #不存在报错
4 print(res) # 4

2、count 元素的数量

1 lst = [1,2,3,4,5,5]
2 res = lst.count(5)
3 print(res)  # 2

3、sort() 列表排序 (基于原有列表进行修改)

针对于数字：

1 # 正序
2 lst=[-1,-4,-6,45,1,100]
3 lst.sort()
4 print(lst) #[-6, -4, -1, 1, 45, 100]
5 #反向
6 lst=[-1,-4,-6,45,1,100]
7 lst.sort(reverse=True)
8 print(lst) #[100, 45, 1, -1, -4, -6]

针对于字母：

ascii 编码进行排序大小写字母ascii相差32

按照ascii编码的大小,一位一位的进行比较,默认从小到大

针对于中文：

能排序,无规律可循

4、reverse 列表反转操作

1 lst=[1,2,3]
2 lst.reverse()
3 print(lst) #[3, 2, 1]

元组相关操作和方法

元组的相关操作除了不能修改和删除其中的元素之外 , 剩下操作都和列表相同.
元组里面能用的方法只有 index 和 count

五、字典的相关函数

1、增加

（1）使用键值来来增加

dic = {}
dic["top"] = "廉颇"
dic["middle"] = "妲己"
dic["bottom"] = "孙尚香"
print(dic) # {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香'}

（2) fromkeys() 使用一组键和默认值创建字典 (快速定义字典)

1 lst = ["a","b",'c']
2 # fromkeys(塞满键的容器,默认值)
3 dic = {}.fromkeys(lst,None)
4 print(dic) # {'a': None, 'b': None, 'c': None}

注意点慎用

1 dic = {}.fromkeys(lst,[])
2 dic["a"].append(1)
3 print(dic) #{'a': [1], 'b': [1], 'c': [1]}

2、删除

（1）pop() 通过键去删除键值对 (若没有该键可设置默认值,预防报错)

dic = {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香',"jungle":"猴子","support":"小明"}
# 指定键删除对应的键值对
res = dic.pop("jungle")
# 若没有该键可设置默认值,预防报错
res = dic.pop("middle123434","抱歉,该键不存在")
print(res)
print(dic)  #抱歉,该键不存在

（2）popitem() 删除最后一个键值对

1 dic = {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香',"jungle":"猴子","support":"小明"}
2 res = dic.popitem()
3 print(res) #('support', '小明')
4 print(dic) #{'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香', 'jungle': '猴子'}

（3）clear() 清空字典

1 dic.clear()
2 print(dic) #{}

3、改变

（1）update() 批量更新(有该键就更新,没该键就添加

 1 dic =  {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香'}
 2 
 3 # 没该键就添加
 4 dic_new = {"support":"瑶"}
 5 dic.update(dic_new)
 6 print(dic) #{'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香', 'support': '瑶'}
 7 
 8 # 有该键就更新
 9 dic_new = {'middle': '武则天'}
10 dic.update(dic_new)
11 print(dic) #{'top': '廉颇', 'middle': '武则天', 'bottom': '孙尚香', 'support': '瑶'}

4、查找

（1）get() 通过键获取值(若没有该键可设置默认值)

1 dic =  {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香'}
2 # 没有该键不报错返回None
3 res = dic.get("top123")
4 res = dic.get("top123","抱歉,改键不存在")
5 # res = dic["top"]
6 print(res)

5、其他方法

（1）keys() 将字典的键组成新的可迭代对象

1 dic =  {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香'}
2 res = dic.keys()
3 print(res , type(res))
4 #dict_keys(['top', 'middle', 'bottom']) <class 'dict_keys'>

（2）values() 将字典中的值组成新的可迭代对象

1 dic =  {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香'}
2 res = dic.values()
3 print(res , type(res))
4 #dict_values(['廉颇', '妲己', '孙尚香']) <class 'dict_values'>

（3） items() 将字典的键值对凑成一个个元组,组成新的可迭代对象

1 dic =  {'top': '廉颇', 'middle': '妲己', 'bottom': '孙尚香'}
2 res = dic.items()
3 print(res , type(res))
4 #dict_items([('top', '廉颇'), ('middle', '妲己'), ('bottom', '孙尚香')]) <class 'dict_items'>

for k,v in dic.items():
    print(k,v)
'''
top 廉颇
middle 妲己
bottom 孙尚香
'''

六、集合相关的操作

1、交差并补

 1 set1 = {"郭杰瑞","药水哥","张大仙","王文"}
 2 set2 = {"蔡徐坤","王力宏","郭德纲","王文"}
 3 
 4 # 1.交集
 5 res = set1.intersection(set2)
 6 print(res) #{'王文'}
 7 
 8 # 简写 
 9 res = set1 & set2
10 print(res)
11 
12 # 2.差集
13 res = set1.difference(set2)
14 print(res) #{'郭杰瑞', '张大仙', '药水哥'}
15 
16 # 简写 
17 res = set1 - set2
18 print(res) 
19 # 3.union 并集
20 res = set1.union(set2)
21 print(res)  #{'王文', '郭德纲', '张大仙', '王力宏', '郭杰瑞', '蔡徐坤', '药水哥'}
22 
23 # 简写 
24 res = set1 | set2
25 print(res) 
26 
27 # 4.symmetric_difference
28 res = set1.symmetric_difference(set2)
29 print(res) #{'郭德纲', '张大仙', '王力宏', '郭杰瑞', '蔡徐坤', '药水哥'}
30 
31 # 简写 
32 res = set1 ^ set2
33 print(res)

2、其他方法

（1）issubset() 判断是否是子集

1 set1 = {"王文","王宝强","王健林","王思聪"}
2 set2 = {"王文","王宝强"}
3 res = set2.issubset(set1)
4 print(res)
5 # 简写
6 res = set2 < set1
7 print(res)

（2）issuperset() 判断是否是父集

1 set1 = {"王文","王宝强","王健林","王思聪"}
2 set2 = {"王文","王宝强"}
3 res = set1.issuperset(set2)
4 print(res)
5 
6 # 简写
7 res = set1 > set2
8 print(res

（3）isdisjoint() 检测两集合是否不相交不相交 True 相交False

1 set1 = {"王文","王宝强","王健林","王思聪"}
2 set2 = {"王文","王宝强"}
3 res = set1.isdisjoint(set2)
4 print(res) #False

3、增加

1.一次加一个

1 setvar = {"周润发"}
2 setvar.add("周星驰")
3 setvar.add("周树人")
4 print(setvar)

2.一次加一堆

update() 迭代着增加

1 setvar = {"马诺"}
2 lst = "abc"
3 setvar.update(lst)
4 print(setvar) #{'c', 'a', '马诺', 'b'}

4、删除

（1）clear() 清空集合

1 setvar.clear()
2 print(setvar)

（2）pop() 随机删除集合中的一个数据

1 setvar = {'张大仙', '郭杰瑞', '药水哥', '郭德纲', '蔡徐坤', '王力宏'}
2 res = setvar.pop()
3 print(res)
4 print(setvar)

（3）remove() 删除集合中指定的值(不存在则报错) (了解)

1 setvar.remove("张大仙")
2 # setvar.remove("张大仙1233434343") error
3 print(setvar)

（4）discard() 删除集合中指定的值(不存在的不删除推荐使用)

1 setvar.discard("郭杰瑞")
2 setvar.discard("郭杰瑞11122333")
3 print(setvar)

5、冰冻集合 (扩展)

冰冻集合一旦创建,不能在进行任何修改,只能做交差并补操作

frozenset 可强转容器类型数据变为冰冻集合

1 lst = ["马蓉","马化腾","马户","马云","码农"]
2 fz = frozenset(lst)
3 print(fz,type(fz)) #frozenset({'马化腾', '码农', '马户', '马蓉', '马云'}) <class 'frozenset'>

标签：python,res,之路,dic,学习,lst,print,strvar,True
来源： https://www.cnblogs.com/yj0405/p/14033015.html

我的python学习之路-基础2

一、流程控制

1、顺序结构

2、分支结构

1、单分支结构

2、双分支结构

3、多分支结构

4、巢状分支

3、 循环结构

1、while 循环

2. for循环

2.1 range的三种用法对象 (留头舍尾)

1.range( start , end , step )

2. range( start , end )

3.range(end) 从0开始,留头舍尾

3、pass、break、continue 关键字的应用

二、字符串的格式化 format

1、顺序传参

2、索引传参

3、关键字传参

4、容器类型数据传参

5、format 填充符号的使用

6、进制转换等特殊符号的使用(:d :s :f)

三、列表、元组的操作

1.列表的拼接 (同元组)

2.列表的重复（同元组）

3、列表的切片（同元组）

4、列表的获取 (同元组)

5、列表的修改( 可切片 )

1）、一次修改一个

2）、一次修改多个 ,等号右边必须是Iterable(容器类型的数据 range对象 迭代器)

3）、一次修改多个(带步长) 截取几个,修改几个

5、列表的删除（可切片）

1）、 一次删除一个

2）、一次删除多个

3）、注意点 (改写法删除的是res 变量,不是列表)

四、列表、元组的相关方法

1、增加

1、append 向列表的末尾添加新的元素

2、insert 在指定索引之前插入元素

3、extend 迭代追加所有元素

2、删除

1、pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)

2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个

3.clear 清空列表

3、其他操作

1、index 获取某个值在列表中的索引

2、count 元素的数量

3、sort() 列表排序 (基于原有列表进行修改)

4、reverse 列表反转操作

五、字典的相关函数

1、增加

2、删除

3、改变

4、查找

5、其他方法

六、集合相关的操作

1、交差并补

2、其他方法

3、增加

4、删除

5、冰冻集合 (扩展)

　　1、单分支结构　

　　2、双分支结构

　　3、多分支结构　　

　　4、巢状分支

3、循环结构

　2. range( start , end )

　3.range(end) 从0开始,留头舍尾

2）、一次修改多个 ,等号右边必须是Iterable(容器类型的数据 range对象迭代器)

1）、一次删除一个