小丑西瓜9

这个屌丝很懒，什么也没留下！

热门标签

Python学习之旅--容器_{name: 0 for name in self.names}

作者：小丑西瓜9 | 2024-05-28 08:49:59

踩

{name: 0 for name in self.names}

1,字符串

目的: 知道字符串的格式

操作流程:

三种格式

# 1, 字符串,单引号形式
name = '张三'
print(type(name))

# 2, 字符串, 双引号的形式
product = "UiBot"
print(type(product))

# 3,字符串, 三引号形式
company = """赵jc123213..."""
print(type(company))
1
2
3
4
5
6
7
8
9
10
11

2,输入输出

目的: 知道字符串的输出形式, 和输入格式

操作流程:

# 1, 字符串, 格式化输出一
name = "迪丽热巴"
age = 23
print("她的名字是%s, %d岁了"%(name,age))

# 2, 字符串, 格式化输出二, f-string
print(f'她的名字是:{name}, {age}岁了')

# 3, 字符串, 格式化输出三, format
print("她弟名字是:{}, {}岁了".format(name,age))

print("====================华丽分割线======================")

# 4,字符串输入
product = input("请输入你要学习的内容:")
print("学习的是 = {}".format(product))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3,切片

目的: 可以通过切片方法, 截取字符串内容

操作流程:

"""
格式:
    name[start:end:step]
    start: 开始位置的索引(包含),默认值0
    end: 结束位置索引(不包含),默认值字符串长度
    step: 步长,默认1
"""
name = "helloworld"
print(name[0:10:1]) # helloworld, 里面默认值
print(name[::]) # helloworld, 和上面等价

# 1, 截取name中的hello
print(name[0:5:])

# 2, 截取name中的world
print(name[5::])

# 3,截取name中的llo
print(name[2:5:])

# 4,获取name中的指定位置的字符串
print([name[::2]])

# 5,面试题: 使用切片的方式将字符串进行反转 
print(name[::-1]) # 等价于 name[-1:-len(name)-1:-1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4, 字符串方法

目的: 了解python中常见的字符串方法

操作流程:

需要掌握的: +连接的, 获取值的, lower,upper,split

#1,字符串连接操作 +
print("hello" + "world")
print(3*"hello" + "world")
name = "hello"
print(name + "zjc")

#2,获取字符串中的字符, 格式, 字符串[索引]
print(name[0])
print(name[1])

#3,capitalize,首个字符大写，其余为小写
print("hello world".capitalize()) # Hello world

#4,casefold, 大写转小写,支持德语
print("hello WorlD".casefold()) #hello world

#5,center, 当指定长度大于字符串长度,两边补空格
print("zjc".center(10))

#6,count,指定字符在指定位置出现的次数
print("helloworld".count("l",0,6))

#7,endswith, 判断字符是否已指定的字符串结尾
print("加藤.avi".endswith(".avi"))

#8,find,查找字符串位置,不存在返回-1
print("helloworld".find("lloa"))

#9,format_map,格式化输出对象
class Default(dict):
    def __missing__(self, key):
        return "荷兰"
print('{name} was born in {country}'.format_map(Default(name='Guido')))

#10,index,查找字符串位置,不存在报错
# print("helloworld".index("lloa"))

#11, isspace,判断字符串是不是只有空白
print("   a".isspace())

#12,join, 将列表连接成一个字符串
print("---".join(["A","B","C"])) # A---B---C

#13,lower,将字符串全部转小写
print("HELLOzjcPython".lower())

#14,lstrip
print('aaa.example.com'.lstrip('cmowza.'))

#15,partition, 使用指定的符号将字符串切割成三部分
print("hello,world,python,zjc".partition(","))

#16,split, 使用指定的符号将字符串切割成若干块
print("hello,world,python,zjc".split(","))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

官方字符串方法: https://docs.python.org/zh-cn/3.8/library/stdtypes.html#string-methods

5, 列表

目的: 知道列表的格式, 遍历方式
作用: 用来存储多个元素的容器

操作流程:

#1, 定义列表
names = ["迪丽热巴","古力娜扎","马尔扎哈",100]
print(names)

#2,获取列表的值, 列表名称[索引]
# 索引取值: [0, 列表长度-1], 如果超出报错
print(names[0])
print(names[1])
print(names[2])
print(names[3])
print("================")

#3,遍历列表
for i in range(0,len(names)):
    print(names[i])

#4,获取列表长度,方法
print(len(names))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6, 列表方法

目的: 掌握列表中常见的操作方法

操作流程

#1,添加元素,append, extend, insert
names = ["迪丽热巴","古力娜扎","马尔扎哈"]
names.append("刷我滴卡")
names.extend(["A","B"]) # names += ["A","B"]
names.insert(1,"鹿晗")
print(names)

#2,修改元素
names[0] = "热巴"
print(names)

#3,查找 in, not in(Boolean), index, count
print("鹿晗" not in names)
print(names.index("A"))
print(names.count("A"))

#4,删除 del, pop, remove
# del names[0] #删除之后,没有返回值
# print(names.pop(0))# 删除之后,有返回值, 根据索引来删除的
names.remove("鹿晗")# 删除之后,没有返回值, 根据元素来删除的
print(names)

#5,列表反转
temp = [1,2,3,4,5]
temp.reverse()
print(temp)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

7, 列表嵌套

目的: 了解列表的嵌套方式, 以及遍历过程

操作流程

#1,列表嵌套
# man_names = ["王宝强","徐峥","黄渤"]
# woman_names = ["迪丽热巴","古力娜扎","马尔扎哈"]
people_names = [["王宝强","徐峥","黄渤"],["迪丽热巴","古力娜扎","马尔扎哈"]]

#2,遍历
for item in people_names:
    for name in item:
        print(name)
1
2
3
4
5
6
7
8
9

8, 元祖

目的: 知道元祖的定义格式,取值方式,遍历

操作流程

"""
元祖特点:
    1, 数据不允许修改, 添加
    2, 配合字典使用作为key
    3, 当一组数据定义好之后,不允许别人修改,可以使用元素
"""

#1, 定义元素
names = ("迪丽热巴","古力娜扎","马尔扎哈")
print(names[0])
print(len(names))

#2,遍历, 和列表完全一样
for i in names:
    print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9, 字典

目的: 掌握字典的作用, 定义方式, 取值方式

操作流程

"""
字典作用:
    用来详细的描述一件事物

字典定义格式:
    {key: value, key2:value2}

字典取值:
    字典名[key]
"""

#1,定义字典
person = {
    "姓名":"迪丽热巴",
    "身高":"167cm",
    "体重":50,
    "公司":"TVB"
}
print(person)

#2,获取字典元素
print(person["身高"])

#3,遍历,获取到的是key, 需要用key来取值
for key in person:
    print(f"key = {key}, value = {person[key]}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

10,字典方法

目的: 掌握字典中的常见增删改查方法

操作流程

#1, 定义字典, 添加元素
person = {
    "姓名":"迪丽热巴",
    "身高":"167cm",
    "体重":50,
    "公司":"TVB"
}
person["性别"] = "女"
# print(person)

#2,修改
person["性别"] = "woman"
# print(person)

#3,删除
del person["性别"]
print(person)

#4,查, in ,not in
# print("公司" in person)

#5,额外方法
#5,1 获取字典中所有的key
print(person.keys())

#5,2 获取字典中所有的value
print(person.values())

#5,3 将元素转换成元祖
print(person.items())

#5,4 遍历
for key,value in person.items():
    # print(f"{key},{person[key]}")
    # print(key)
    print(f"key = {key}, value = {value}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

11,通用方法

目的: 掌握python中内置的常见通用方法

操作流程:

#1, 列表相加
print([1, 2] + [3, 4] * 2)

#2, len
print(len([1,2,3]))
print(len((1,2,3)))
print(len({"name":"张三","age":13}))

#3, max,min
print(max([4,5,6,6,2,2,34,1]))
print(min([4,5,6,6,2,2,34,1]))

#4,del 删除的是字典列表
a = (1,2,3) #不能删除
b = [1,2,3]
c = {"a":1,"b":2}
del c["a"]
print("=========================")

"""
5,练习,需求: 通过a-z,A-Z,0-9随机生成一个32位的随机字符串
应用场景: 加密过程中用到的字符串, sha1
"""
import string
import random
# print(string.ascii_letters) # 52个大小写字符
# print(string.digits) # 0123456789十个数字
base_string = string.ascii_letters + string.digits
random_list = random.choices(base_string,k=32)# 根据提供的字符串,随机获取32位
random_string = "".join(random_list)
print(random_string)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

12, lambda

目的: 知道什么是lambda表达式, 以及他的作用

操作流程:

"""
lambda表达式格式(匿名函数):
    lambda 参数1,参数2: 代码
    
注意点:
    1, 参数不能写类型
    2, 代码里面不能写复杂逻辑,比如return, for, if
    3, lambda表达式定义后之后,需要马上执行
    
作用:
    1, 通过lambda表达式可以快速去执行一段逻辑
    2, 可以当成参数进行传递
"""""

#1, 无参数,无返回值
(lambda : print("这是一个神奇的函数"))()

#2, 无参数,有返回值
a = (lambda : 10 + 20)()
# print(a)

#3, 有参数,无返回值
(lambda num1,num2: print("num1 = {},num2={}".format(num1,num2)))(5,15)

#4, 有参数,有返回值
b = (lambda num1,num2: num1 * num2)(4,6)
print(b)
print("========================")

def login(check):
    result = check("zhangsan","123456")
    return result

result = login(lambda username,passsword: username + "," +  passsword)
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

13, 推导式

目的: 可以通过推导式遍历列表,元祖,字典, 并且可以通过字典推导式创建字典

操作流程:

#1, "列表"推导式: 快速遍历列表,元祖,字典的
# names = ["张三","李四","王五"]
# names2 = ("张三","李四","王五")
# [print(name) for name in names]
# [print(name) for name in names2]
# person = {
#     "姓名":"迪丽热巴",
#     "年龄":13,
#     "性别":"女"
# }
# [print(f"{p}, {v}") for p,v in person.items()]

#2, 字典推导式, 可以根据两个列表快速构建出一个字典来
names = ["迪丽热巴","古力娜扎","马尔扎哈"]
starts = ["天蝎座","狮子座","处女座"]
dict = {key:value for key,value in zip(names,starts)} # zip(names,starts) => ((迪丽热巴,天蝎座),(古力娜扎,狮子座))
print(dict)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

14, 集合

目的: 可以通过集合求出列表的交集,并集,补集

操作流程

"""
集合格式:
    {value1, value2, value3,...}
"""

#1, 定义列表,转换成集合
names = [1,2,3]
ages = [2,3,4]
x_names = set(names)
x_ages = set(ages)

#2,求出集合的交集
x_result = x_names & x_ages
print("集合的交集 = {}".format(x_result))

#3,求出集合的并集
y_result = x_names | x_ages
print("集合的并集 = {}".format(y_result))

#4,求出集合的差集
z_result = x_names - x_ages
print("集合的差集 = {}".format(z_result))

#5,将集合转换列表
print(list(z_result))
print(type(list(z_result)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

注意点:
- set集合可以自动去重
- 添加的元素无序

15, 容器转换

目的: 可以实现list,tuple,set之间的相互转换

操作流程

#1, list->tuple,set
a = [1,2,3]
a_tuple = tuple(a)
a_set = set(a)
# print(a_tuple)
# print(a_set)

#2,tuple->list,set
b = [4,5,6]
b_list = list(b)
b_set = set(b)
# print(b_list)
# print(b_set)

#3,set->tuple,list
c = set()
c.add("A")
c.add("B")
c.add("B")
c.add("C")
c_list = list(c)
c_tuple = tuple(c)
print(c_list)
print(c_tuple)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

总结

1, 字符串, 格式’’, “”, “”" “”"

2, 输入,输出; input, print, f’{},{}’, format

3, 切片, name[start,end,step]; 包头不包位; 反转面试题; name[::-1]

4, 字符串常见方法, +, name[索引], lower, upper, find, index

5, 列表方法, [], append, extend, insert, del, pop, remove, reserve

6, 元素, (), 特点: 数据不能改变

7, 字典, {key:value}, 特点: 键值对, del, keys(), values(), items()

8, len, max, min, string.ascii_letters, digits, random.choice(base_string,k=32)

9, lambda,匿名函数,快速执行逻辑,还需要当成参数传递

10, 推导式,列表,字典

11, 集合,容器,方便对数据进行差集,并集,交集获取

12, 容器转换,set,list,tuple

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/636640