python基础-变量，变量类型，字符串str，元组tuple，列表list，字典dict操作详解（超详细）_python str tuple

python基础——变量

（文章较长，若需要单独看某一个点，可点击目录直接跳转）

python是一门弱类型的编程语言，python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量就被创建了。

在python中，变量没有类型，我们所说的类型，是指变量所指内存中对象的类型。这就是为什么在python中一个变量名可以被赋予不同类型的值，也就是说，变量的数据类型可以随时改变，同一变量可以一会儿是数值类型，一会儿是字符串型

在python中，使用= 来给变量赋值。

等号(=)运算符左边是一个变量名，右边是存储在变量中的值

例如：

变量名 = 值
year = 2022		# 整型类型
mood = "happy"	# 字符串
1
2
3

1. 变量

变量：会变化的量，用来记录事物的状态，属性等。

• 变量的命名规则：
  • 变量名只能是字母，数字或下划线的任意组合
  • 数字不能作为变量名的开头
  • 关键字不能作为变量的开头
  • 驼峰命名法
    • 小驼峰：除第一个单词首字母小写，后续单词首字母均大写，例如：firstName
    • 大驼峰：每个单词首字母均大写，例如：：FirstName

name = "XiaoWangZi"
print(name)
1
2

这里补充一下关键字：关键字就是在python内部已经使用过的标识符，变量名，就是我们自己命名的标识符。

# 开发者可以通过python程序来查看它所包含的关键字
# 例如如下程序：
import keyword  # 导入keyword模块
print(keyword.kwlist)  # 显示所有关键字

# 注意事项：不能使用一系列关键字和内置函数名作为变量名
# >>如果使用关键字作为变量名，python解释器会报错
# >>如果使用内置函数名作为变量名，python解释器倒不会报错，只是该内置函数就被这个变量覆盖了，该内置函数就不能使用了
1
2
3
4
5
6
7
8

• 变量的使用规则
  程序从上至下运行

name1 = "XiaoWangZi"
name2 = name1
print(id(name1))
print(id(name2))
print(name1, name2)

name1 = "XiaoC"
print(name1, name2)
1
2
3
4
5
6
7
8

运行上面程序，可以看到运行结果如下图：

2. 变量类型

• 数字类型

• 非数字类型

在python中，我们可以使用 tpye() 函数输出变量类型
语法如下：

name = "XiaoC"
print(type(name))
1
2

2.1数字类型

# 整型 int
# python的整型数值有4种表达形式
# >1>十进制形式：最普通的整数就是十进制形式的整数
# >2>二进制形式：以 0b 或 0B开头的整数就是二进制形式的整数
# >3>八进制形式：以 0o 或 0O开头的整数就是八进制形式的整数（第二个字母是大写或小写的o）
# >4>十六进制形式：以 0x 或 0X开头的整数就是十六进制的整数，其中10~15分别以a~f（此处a~f不去分辨大小写）来表示

# 以 Ox ox 开头的整型数值是十六进制形式的整数
hex_valuel = 0x13
hex_value2 = 0XaF
print("hexValuel 的值为：",hex_valuel)
print('hexValue2 的值为：',hex_value2)

# 以 Ob OB 开头的整型数值是 进制形式的整数
bin_val = 0b111
print('bin_val 的值为:',bin_val)
bin_val = 0B101
print('bin_val 的值为：',bin_val)

# 0o 0O 开头 整型数值是八进制形式的整数
oct_val = 0o54
print('oct_val 的值为：',oct_val)
oct_val= 0o17
print('ct_val 的值为：',oct_val)

# 浮点型 float  用于保存带小数点的数值
# 两种表现形式：
# 十进制形式：浮点数必须包含一个小数点，否则会包当成整数处理。十进制即为平常简单的浮点数
# 科学计数法：例如：5.12e2（即5.12*10^2）,5.12E2(也为5.12*10^2)
# 注意：只有浮点数才可以使用科学计数法形式表示。例如51200是一个整型数值，但是 512E2 则是浮点型
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

# 整数类型 int
age = 18
year = 2021
print(type(age))

# 浮点型 float
weight = 58.5
print(type(weight))

#  数据类型的使用  + - / *
level = 1  # 游戏等级
level = level + 1  #升了一级
print(level)

# 布尔 bool boolean 非真既假
is_ok = True  # 真
is_ok = False  # 假

number1 = 10
number2 = 20

print(number1>number2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.2 字符串

python中字符串用单引号' 或双引号" 括起来

如果要在字符串中使用特殊字符，需要用反斜杠\ 转义

name = 'XiaoC'
salary = '36W'
1
2

• 字符串相加

name = 'XiaoC'
salary = '36W'
print(name + "的薪酬是年薪" + salary)
1
2
3

长字符串：我们使用三个引号定义长字符串

question = "When is it now?"
answer = '''
	今天是周四
	今天是2022/01/20
	现在是凌晨两点
	'''
print(question + "\n" + answer)
1
2
3
4
5
6
7

• 字符串相乘

name = 'XiaoC'
salary = '36W'
print(name + "的薪酬是年薪" + salary*3) # 重要事情说三遍
1
2
3

• 字符串操作详解

# project:字符串和input函数
# 字符串的意思 就是”一串字符“，比如”hello，charlie“是一个字符串，”how are you？“也是一个字符串
# python要求字符串必须使用括号括起来，单双引号都行，只要两边的引号能配对即可


# 字符串和转义字符
# 字符串的内容几乎可以包含任何字符，英文字符也行，中文字符也行
# 注意：在python 2.x中若要对中文字符支持，则要求在源程序中增加"#coding:utf-8"才能支持中文字符

# 如果字符串内容本身包含了单引号或双引号，此时需要进行特殊处理：
# >>使用不同的引号将字符串括起来
# >>对引号进行转义  \'     \"
# 例如：
str1 = '"spring is here,let us jam!",said woodchuck'
print(str1)
str2 = '"we are scared,let\'s hide in the shade",says the bird'
print(str2)


# 拼接字符串
# 如果将两个字符串紧挨在一起，python会自动拼接它们，例如以下代码
s1 = 'hello','charlie'
print(s1)          # ('hello', 'charlie')
# # 上面的写法只是书写字符串的一种特殊方法，并不能真正用于拼接字符串。
# # python中使用加号（+）作为字符串拼接运算符，例如如下代码：
s2 = 'Python '
s3 = 'is Funny'
s4 = s2 + s3
print(s4)

address = '湖南省长沙市'
msg = '''
    你好
    同学们好
    大家好
    '''
print(address + msg)
print(address*5) #乘法  拼接对应的次数


print('============================================')

# repr和字符串
# 有时候，我们需要将字符串与数值进行拼接，而python不运行直接拼接数值和字符串，程序必须先将数值转换成字符串
# 为了将数值转换成字符串，可以使用str（）或repr（）函数，例如如下代码：
s5 = "这本书的价格是："
p = 99.8
print(s5 + str(p))   # 强制类型转换，将数值转换成字符串
print(s5 + repr(p))
# str（）和repr（）都可以将数值转换成字符串，其中str是python内置的类型（和int，float一样）
# 而repr（）则是一个函数，此外，repr还有一个功能，它会以python表达式的形式来表示值
# 对比如下两行print代码：
st = "I will play my life"
print(st)
print(repr(st))
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
55

2.3 列表

列表：存储，记录多个同种属性的值

虽然这样定义列表，但是列表的元素类型可以不相同，它支持数字，字符，甚至可以在里面嵌套列表。

python列表是写在方括号[]之间，列表元素之间用英文半角状态下的逗号, 隔开

• 列表数据的获取

列表计数，从0为开始值，-1 为末尾的开始位置

stu_name = ['段同学','张同学','岳同学']  # 列表的存储

# 列表内的数据获取  列表计数  从 0 开始
name = stu_name[1]
print(name)

# 列表的嵌套使用 学员信息
student_info = [
                ['jack',18,['play','paint']],
                ['rose',16,['游泳','骑车']]
                ]
# 取第二位同学的第一个爱好  姓名 年龄  爱好  同级别
print(student_info[1][2][0])

names="zhang Gu Xiang Xu"
names=["zhang","Gu","Xiang","Xu"]
# 切片
print(names[0],names[1],names[2])
print(names[1:3])  # 顾头不顾尾，切片
print(names[-1]) # 在不知道多长情况下，取最后一个位置
print(names[-1:-3]) # 切片是从左往右，此时不输出
print(names[-3:-1]) # 顾头顾尾，去最后三个
print(names[-2:])  # 取最后两个
print(names[0:3]) # 切片 等价于 print(names[:3])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

"""
列表 list
定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
特点：
1. 可存放多个值
2. 按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
3. 可修改指定索引位置对应的值，可变
"""

# 类型转换 list()
# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，
# list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
name = 'XiaoC'
print(list(name))
number = 1234
# print(list(1234)) #数字是不能被转换的
print(list({'name':'XiaoC','age':18}))   # 转换字典只会拿到key
print('============================================')

# 查询 index 下标
cars = ['奥迪','宝马','大众','奥拓','宝马']
print(cars[2])
print(cars[1:3])  # 从第一个坐标开始取,到小于第二个下标终止
print(cars[-1])   # 奥拓
print(len(cars))   # 获取长度  len()
print('宝马' in cars)   # 成员运算  in    not in

# index() 查找某个元素存在列表的下标
print(cars.index('大众'))

# count() 统计某个元素出现的次数
print(cars.count('宝马'))
print('============================================')

# 修改 index 下标
# 单个修改 通过下标  正反下标都可
cars = ['奥迪','宝马','大众','奥拓']
cars[1] = '宝骏'
print(cars)

# 修改多个元素
cars[1:3]=['五菱宏光','长安之星']
print(cars)

cars[4:4] = ['汗血宝马']  # 如果切片索引不存在,则会新增 切片不支持单个元素操作
print(cars)


# 增加 insert()--插入 append()--追加 extend()--合并
cars = ['奥迪','宝马','大众','奥拓']
# insert 插入任意位置 insert(新增内容下标,新增内容)
cars.insert(2,'标致')
print(cars)
# append()  追加元素到列表尾部
cars.append('劳斯莱斯')
print(cars)
# extend() 合并
food = ['fish','egg','milk']
cars.extend(food)
print(cars)
print(food)
print('============================================')

# 删除 del  pop()  remove()  clear()
# del 通过索引来删除 包含正负
del food[0]
print(food)
del cars[-1]
print(cars)
# del 通过列表名 直接删除整个列表
# del food
# print(food)

# pop() 删除指定索引处的元素
print(cars)
cars.pop(6)
print(cars)
cars.pop() # 不设置下标,默认删除最后一个元素
print(cars)

# remove 根据元素的值去删除 如果有重复的元素,只会删除第一个
numbers = [1,2,7,86,34,56,7,59,100]
numbers.remove(1)
# print(numbers)
numbers.remove(7) # 删除第一个7
# print(numbers)
# numbers.remove(10) # 不存在元素则会报错  x not in list
# print(numbers)

# clear 删除所有元素
numbers.clear()
print(numbers)
print('==============================================')

# 排序 sort()   reverse=True 反向排序
numbers = [1,2,7,86,34,56,7,59,100]
numbers.sort(reverse=True) # numbers.sort(reverse=True)  反向排序
print(numbers)
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

• 列表操作详解

# project：使用列表

# 列表和元组的不同：是否可以改变
# 虽然大部分时候都可以使用列表代替元组，但是如果程序不需要修改列表所包含的元素
# 那么使用元组代替列表会更安全

# 创建列表
# 除了前面介绍的方括号语法外，python还提供了内置函数来创建列表
# list（） 函数来创建列表，list（）函数可用于将元组、区间（range）等对象转换为列表
# 示范程序：
a_tuple = ('crazyit', 20, -1.2)
# 将元组转换成列表
a_list = list(a_tuple)
print(a_list)

# 使用range（）函数创建区间（range）对象
a_range = range(1, 5)
print(a_range)  # range(1, 5)
# 将区间转换成列表
b_list = list(a_range)
print(b_list)   # [1, 2, 3, 4]

# 创建区间时还可以指定步长
c_list = list(range(4, 20, 3))
print(c_list)  # [4, 7, 10, 13, 16, 19]

print('===========================================')

# 与list（）对应，python还提供了一个tuple（）函数
# tuple（）该函数用于将列表、区间（range）等对象转换为元组
# 示范程序：
a_list = ['craazyit', 20, -1.2]
# 将列表转换成元组
a_tuple = tuple(a_list)
print(a_tuple)

# 使用range（）函数创建区间（range）对象
b_range = range(1, 5)
print(b_range)  # range(1, 5)
# 将区间转换成元组
b_tuple = tuple(b_range)
print(b_tuple)  # [1, 2, 3, 4]

# 创建区间时还可以指定步长
c_tuple = tuple(range(4, 20, 3))
print(c_tuple)  # [4, 7, 10, 13, 16, 19]

# 增加、删除、修改列表元素（疯狂python讲义63页）
print('=============================================')
# 增加列表元素
# append()   把传入的参数追加到列表的最后面
# 既可接收单个值，也可接收元组、列表等，但这时只是把元组、列表当成单个元素
#   这样就会形成在列表中嵌套列表、嵌套元组的情形
# 例如：
a_list = ['crazyit', 20, -2]
a_list.append('fkit')
print(a_list)       # ['crazyit', 20, -2, 'fkit']
a_tuple = (3.4, 5.6)
a_list.append(a_tuple)     # 元组被当成一个元素
print(a_list)               # ['crazyit', 20, -2, 'fkit', (3.4, 5.6)]

a_list.append(['a', 'b'])   # 列表被当成一个元素
print(a_list)            # ['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]

print('===============================================')
# 如果希望不将被追加的列表当成一个整体的元素，而只是追加列表重点额元素
# 则使用：
# eextend()
b_list = ['a', 30]
b_list.extend((-2, 3.1))     # 追加元组中的所有元素
print(b_list)              # ['a', 30, -2, 3.1]
b_list.extend(['C', 'R', 'A'])
print(b_list)              # ['a', 30, -2, 3.1, 'C', 'R', 'A']
b_list.extend(range(97,100))    # 追加区间中所有元素
print(b_list)           # ['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

print('===========================================')
# 在列表中间增加元素
# insert()    指定元素插入位置
c_list = list(range(1, 6))
print(c_list)          # [1, 2, 3, 4, 5]
c_list.insert(3, 'CRAZY')
print(c_list)           # [1, 2, 3, 'CRAZY', 4, 5]
c_list.insert(3,tuple('crazy'))
print(c_list)          # [1, 2, 3, ('c', 'r', 'a', 'z', 'y'), 'CRAZY', 4, 5]


print('===============================================')
# 删除列表元素
# del   既可删除单个元素，也可直接删除列表中间一段
a_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']
del a_list[2]      # 删除第三个元素
del a_list[1: 3]   # 删除第2到第4个元素

b_list = list(range(1, 10))
del b_list[2: -2: 2]     # 指定步长为2

'''
del 不仅可以删除列表元素，也可以删除普通变量
例如：
name = 'crazyit'
del name
print(name)   # NameError
'''

# remove()  删除列表元素
# 根据元素本身来执行操作，只删除找到的第一个元素（从左向右）
# 如果找不到该元素，会引发ValueError错误
c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
c_list.remove(30)      # 删除第一次找到的30
c_list.remove('crazyit')      # 删除第一次找到的'crazyit'
print(c_list)


# clear()   清空列表所有元素
# 注意，如果del的执行对象是列表名 ，是直接删除列表
c_list.clear()
print(c_list)       # []


print('=============================================')
# 修改列表元素

# 列表元素相当于变量，因此程序可以对列表元素赋值
# 这样即可修改列表元素
a_list = [2, 4, -3.4, 'crazyit', 23]
a_list[2] = 'fkit'
a_list[-2] = 9527
print(a_list)               # [2, 4, 'fkit', 9527, 23]

# 也是使用slice语法对列表中一部分赋值
# 在执行这个操作的时候不要求新赋值的元素个数与原来的元素个数相等
# 这意味着这种方式既可为列表修改元素，也可为列表删除元素
# 例如：
b_list = list(range(1, 5))
print(b_list)
b_list[1: 3] = ['a', 'b']
print(b_list)           # [1, 'a', 'b', 4]

# 如果对空的slice赋值，就成了为列表插入新元素
# 将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入元素
b_list[2: 2] = ['x', 'y']
print(b_list)          # [1, 'a', 'x', 'y', 'b', 4]

# 为列表中一段赋值为空列表，就变成从列表中删除元素
b_list[2: 5] = []
print(b_list)          # [1, 'a', 4]

# 对列表使用slice语法赋值时，不能使用单个值
# 如果使用字符串赋值，Python会自动把字符串当成序列处理
# 其中每一个字符都是一个元素
# 例如：
b_list[1: 3] = 'charlie'    # charlie 被Python分解成序列
print(b_list)          # [1, 'c', 'h', 'a', 'r', 'l', 'i', 'e']

# 使用slice语法也可指定step参数
# 但如果指定了step参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等
# 例如
c_list = list(range(1, 10))
# 指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
c_list[2: 9: 2] = ['a', 'b', 'c', 'd']
print(c_list)         # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']


print('===========================================')
# 列表的其他用法
# >>count()   用于统计列表中某个元素出现的次数
# >>index()   用于判断某个元素在列表中的位置
# >>pop()    用于将列表当成“栈”使用，实现元素出栈功能
# >>reverse()    用于将列表中的元素方向存放
# >>sort()    用于对列表元素排序

# count
a_list = [2, 30, 'a', [5, 30], 30]
print(a_list.count(30))    # 2
print(a_list.count([5, 30]))  # 1
print('==========')

# index()    如果列表中没有要定位的元素，则会引发错误
# 可以在index()中传入start、 end参数，用于在列表中范围搜素
a_list = [2, 30, 'a', 'b', 'crazyit',30]
print(a_list.index(30))      # 1
print(a_list.index(30, 2))    # 5  从2开始，定位30出现的位置
# print(a_list.index(30, 2, 4))  # 在索引2到索引4之间定位30出现的位置，找不到，引发错误

print('==========')

# pop()
# 栈是一种特殊的数据结构，它可实现先入后出（FILO）功能
# 即先加入栈的元素，反而后出栈
# 该方法会把元素移出栈，并返回移出的元素
# 下面示范了使用使用列表作为“栈”的示例：
stack = []
# 向栈中入栈三个元素
stack.append('fkit')
stack.append('crazyit')
stack.append('charlie')
print(stack)          # ['fkit', 'crazyit', 'charlie']
# 第一次出栈：最后入栈的元素被移出栈
print(stack.pop())   # charlie
print(stack.pop())   # crazyit
print(stack)         # ['fkit']


print('===========================')
# reverse()   将列表中元素的顺序反转
a_list = list(range(1, 8))
a_list.reverse()
print(a_list)        # [7, 6, 5, 4, 3, 2, 1]

# sort() 对元素进行排序  默认从小到大
a_list = [3, 4, 3.4, -30, 9.3]
a_list.sort()
print(a_list)        # [-30, 3, 3.4, 4, 9.3]
b_list = ['python', 'swift', 'ruby', 'go']
# 默认按字符串包含的字符的编码来比较大小
b_list.sort()
print(b_list)       # ['go', 'python', 'ruby', 'swift']
'''
sort()方法除支持默认排序之外，还可传入key和reverse两个参数
并且这两个参数必须通过参数名指定（这种参数叫关键字参数）
key参数用于为每个元素都生成一个比较大小的“键”；
reverse参数则用于执行是否需要反转排序：默认从小到大
如果将reverse参数设为True，将会改为从大到小
'''
# key和reverse的示范：
# 将key指定为len，指定使用len函数对集合元素生成比较大小的键
# 也就是字符串长度的比较
b_list.sort(key = len)
print(b_list)          # 'go', 'ruby', 'swift', 'python']
# 指定反向排序
b_list.sort(key = len, reverse = True)
print(b_list)          # ['python', 'swift', 'ruby', 'go']

print('=============================================')
# 列表 list  存储 记录 多个同种属性的值
stu_name = ['段同学','刘同学','张同学']  # 列表的存储

# 列表内的数据获取  列表计数  从 0 开始
name = stu_name[1]
print(name)

# 列表的嵌套使用 学员信息
student_info = [
                ['jack',18,['play','paint']],
                ['rose',16,['游泳','骑车']]
                ]
# 取第二位同学的第一个爱好  姓名 年龄  爱好  同级别
print(student_info[1][2][0])
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249

2.4 元组

元祖 tuple

有些时候我们的列表数据不想被人修改时怎么办？
就可以用元组存放，元组又被称为只读列表，不能修改。
用于记录多个固定不允许修改的值，单纯用于取
1
2
3

• 定义：与列表类似，只不过［］改成（）
• 特性：
  1. 可存放多个值
  2. 不可变
  3. 按照从左到右的顺序定义元组元素，下标从0开始访问，有序

#元祖
cars = ('奥迪','长安','比亚迪','宝马')
print(cars[1])
# cars[1] = '五菱宏光'  不支持修改
# print(cars)

#什么样的情况元祖能被修改
#元祖本身是不可变的,但是如果里面存在可变元素,则可变元素可以被修改
#元祖存的只是每个元素的内存地址
data = (99,88,77,['宝马','奔驰'],100)
data[3][1]='路虎'
print(data)

#类型转换
#但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型
#name = 'jingzhe' 不能使用内存地址去转换
print(tuple('jingzhe'))

print(tuple([1,3,5,6,7]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 元组操作总结
# 元组相当于只读列表,只有两个方法一个是count,一个是index

names=('alex','jack','alex')

print(names.count('alex'))
print(names.index('jack'))
# 购物篮程序

product_list=[('Iphone', 5800),
              ('Mac Pro', 9800),
              ('Bike', 5800),
              ('Watch', 10600),
              ('Coffee', 31),
              ('Alex Python', 120),]
shopping_list=[]
salary=input("Input your salary:")

if salary.isdigit():
    salary=int(salary)
    while True:
        '''for item in product_list:
            print(product_list.index(item),item)
        '''
        for index,item in enumerate(product_list):
            print(index,item)
        user_choice=input("选择要买嘛？>>:")
        if user_choice.isdigit():
            user_choice=int(user_choice)
            if user_choice<len(product_list) and user_choice>=0:
                p_item=product_list[user_choice]
                if p_item[1]<=salary:
                    shopping_list.append(p_item)
                    salary-=p_item[1]
                    print("Added %s into shopping cart, your current balance is \033[31;1m%s\033[0m"%(p_item,salary))
                else:
                    print("\033[41;1m你的余额只剩[%s]啦，还买个毛线\033[0m"%salary)
            else:
                print("product code[%s] is not exist!"%user_choice)
        elif user_choice=='q':
            print('-----------shopping list----------------')
            for p in shopping_list:
                print(p)
                print("Your current balance:",salary)
            exit()
        else:
            print("invalid option")
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

2.5 字典

字典 dict

• 定义：字典类型是用key：value形式来存储数据，其中key可以对value有描述性的功能

｛key1:value1,key2:value2｝
1

• 特点

1. key-value结构
2. key必须为不可变数据类型、必须唯一 , 比如：{‘name’:‘XiaoC’,‘name’:‘XiaoW’} 不可取
3. 一个key可存放任意多个value、可修改、可以不唯一
4. 无序
5. 查询速度快 (hash值)

# hash
print(hash('jingzhe'))
# 经过hash运算会得到一个值  2581601278941823029
# dict 会把hash值放入一个列表 [-6,1,45,67,89,100]


# project:使用字典

# 字典 dict dictionary
# 存储多个不同属性的值

# 字典也是python提供得到一种常用的数据结构
# 它用于存放具有映射关系的数据
# 比如有成绩表数据一一语文：79，数学：80，英语：92，这组数据看上去像两个列表，
# 但这两个列表的元素之间有一定的关联关系。如果单纯使用两个列表来保存这组数据，
# 则无法记录两组数据之间的关联关系。为了保存具有映射关系的数据，Python提供了字典，
# 字典相当于保存了两组数据，其中一组数据是关键数据，被称为key；
# 另一组数据可通过key来的问，被称为value

# 注意：字典中通过key来访问value，因此字典中的额ley不允许重复

# 获取字典的值 key - value 方式  key 键   value 值   键值对

# 创建字典
# 程序既可以使用花括号语法来创建字典，也可以使用dict（）函数来创建字典
# 实际上，dict是一种类型，它就是python中的字典类型

# 在使用花括号创建字典是，花括号中应包含多个key-value对
# key与value之间用英文冒号隔开，多个key-value对之间用英文逗号隔开
# 示例程序：
scores = {'语文：': 89, '数学：': 92, '英语：': 93}
print(scores)
# 空的花括号代表空的 dict()
empty_dict = {}
print(empty_dict)

# 使用元组作为 dict 的 key
dict2 = {(20,30):'good', 30:'bad'}
print(dict2)
# 注意：元组可以作为dict的key，但列表不能
# 这是因为dict要求key必须是不可变类型，但列表是可变类型，因此列表不能作为dict的key

print('==============================================')
# 在使用dict（）函数创建字典时，可以传入多个列表或元素参数作为key-value对
# 每个列表或元组元素将被当成一个key-value对、
# 因此这些列表或元组都只能包含两个元素
# 例如：
vegetables = [('celery',1.58),('brocoli',1.29),('lettuce',2.19)]
# 创建了包含三个key-value对的字典
dict3 = dict(vegetables)
print(dict3)  # {'celery': 1.58, 'brocoli': 1.29, 'lettuce': 2.19}
cars = [['BMW',8.5],['BENS', 8.3],['AUDI', 7.9]]
dict4 = dict(cars)
print(dict4)   # {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}

# 创建空字典
dict5 = dict()
print(dict5)  # {}

# 话可以通过为dict（）函数指定关键字参数创建字典
# 此时字典的key不允许使用表达式，例如：
dict6 = dict(spinach = 1.39, cabbage = 2.59)
print(dict6)   # {'spinach': 1.39, 'cabbage': 2.59}
# 这里创建字典时，key直接写，不需要将它们放入引号


# 字典的基本用法  key-value 对
# >>通过key访问value
# >>通过key添加key-value对
# >>通过key删除key-value对
# >>通过key修改key-value对
# >>通过key判断指定的ley-value对是否存在
# 通过key访问value也是方括号语法，和前面介绍的列表元组一样
# 只是此时在方括号中方的是key，而不是列表或元组中的所有

# 示例程序：
# 定义一个人的信息:姓名，年龄，身高
person_info = {'name':'tom','age':18,'height':188.8}
name = person_info['name']
print(name)

print('=============================================')

# 如果要为dict添加key-value对，只需为不存在的key赋值即可
scores = {'语文': 89}

print(scores['语文'])

# 对不存在的key赋值，就是增加key-value对
scores['数学'] = 93
scores[92] = 5.7
print(scores['数学'])
print(scores)  # {'语文': 89, '数学': 93, 92: 5.7}

# 删除dict中的key-value对
# 使用 del 语句，示例：（程序清单如上）
del scores['语文']
del scores['数学']
print(scores)   # {92: 5.7}

# 修改，如果在程序中对存在的key-value对赋值，
# 新的value就会覆盖原有的value
# 这样就可以改变dict中的key-value对
# 示例代码：（程序清单如上）
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDT': 7.9}
cars['BENS'] = 4.3
cars['AUDT'] = 3.8
print(cars)   # {'BMW': 8.5, 'BENS': 4.3, 'AUDT': 3.8}

# 判断字典是否包含指定的key，可以使用 in 或 not in 运算符
# 对于dict而言，in   not in  运算都是基于key判断的
# 例如
# 判断cars是否包含名为AUDI的key
print('AUDI' in cars)   # True

# 注意，列表不允许对不存在的索引赋值，但字典允许直接对不存在的key赋值

print('==================================')
# 字典的常用方法
# 字典有 dict 类代表，因此我们可以使用dir（dict）来查看该类包含哪些方法
# 输入： dir(dict)  命令，就会看到dict包含的方法

# 下面介绍一些dict的方法

# >>clear()  清空字典中所有的key-value对
# 对一个字典执行clear（）方法后，该字典就会变成一个空字典
# 例如：
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDT': 7.9}
print(cars)
cars.clear()  # 清空cars
print(cars)   # {}

# >>get()   根据key获取value
# 相当于方括号语法的增强版，但当使用方括号访问不存在的key时，字典会引发KeyError错误；
# 但如果使用get（）啊访问不存在的key，该方法会简单的返回None，不会导致错误
# 例如：
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDT': 7.9}
print(cars.get('BMW'))  # 8.5
print(cars.get('PORSCHE'))  # None
# print(cars['PORSCHE'])  # KeyError

# update() 方法
# 使用一个字典所包含的key-value对来更新已有的字典
# 在执行update（）方法时，如果被更新的字典中已包含对应的key-value对，那么原来的会被覆盖
# 如果被更新的字典中不包含对应的key-value对，那么该key-value对会被添加进去。
# 例如：
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDT': 7.9}
cars.update({'BMW': 4.5, 'PORSCHE': 9.3})
print(cars)      # {'BMW': 4.5, 'BENS': 8.3, 'AUDT': 7.9, 'PORSCHE': 9.3}


print('=======================================================')
# items()  获取所有的key-value对  返回： dict_items
# keys()   获取所有的key    返回： dict_keys
# values()  获取所有的value   返回： dict_value
# python不希望用户直接操作这几个方法，但可以通过list（）函数把它们转换成列表
# 示例：
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDT': 7.9}
ims = cars.items()
print(type(ims))   # <class 'dict_items'>

# 将dict_items转换成列表
print(list(ims))  # [('BMW', 8.5), ('BENS', 8.3), ('AUDT', 7.9)]

# 访问第二个key-value对
print(list(ims)[1])   # ('BENS', 8.3)

# 另外两个用法类似

# 字典嵌套
student_info = [
    {'name':'tom','age':18,'height':188.8,'hobbies':['music','read']},
    {'name': 'jack', 'age': 29, 'height': 176.8, 'hobbies': ['sleep', 'play']}
]

# 获取jack的第一个爱好
print(student_info[1]['hobbies'][0])

# 获取jack的身高
print(student_info[1]['height'])

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

3. 补充

这里补充两个类型：

• 序列

# project:序列

# python常见的序列类型包括字符串、列表和元组等
# 前面已经介绍过字符串，其实就是一种常见的序列，通过索引访问字符串内的字符程序就是序列的示范程序

# 这节主要介绍序列和元组
# 这两种类型看起来非常相似，最主要区别在于：
# 元组是不可变的，元组一旦包含起来，程序就不能修改元组所包含的成员（就像字符串也是不可变的，程序无法修改字符串所包含的字符序列）
# 但序列是可变的，程序可以修改序列所包含的元素

# 程序中，如果只是固定地保存多个数据项，则不需要修改它们，此时就应该用元组；反之，就应该用序列
# 此外，在某些时候，程序需要使用不可变的对象，比如python要求字典的key必须是不可变的额，此时程序就只能使用元组

# 注意！！！！序列和元组的关系就是可变和不可变的关系
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 集合

# project:使用集合

"""
集合 set
定义：在{}内用逗号分隔开多个元素
集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""


# 集合的定义
# 1 通过set关键字
sa = set()
print(sa)                                                      # set()
li = [1,23,12,3423,54532,5323,12,4]
sb = set(li)                                                   # {1, 54532, 4, 5323, 12, 23, 3423}
print(sb)

# 2 使用大括号
sc = {"呆橘", "花花","须须","障障"}
print(sc)                                                       # {'呆橘', '花花', '障障', '须须'}

# in 操作
if "飒飒" in sc:
    print("2333")
else:
    print("不在这里啊")
                                                              #   不在这里啊

# 利用 sc生成sd
sc ={1,2,34,55,74,4}
sd = {i for i in sc}
print(sd)                                                    #  {1, 2, 34, 4, 74, 55}


# 集合的内置函数
# len 长度
# add 向集合添加元素
sa = {1,2,3,41,12,31,34,6,7,8}
print(len(sa))                                 # 10
print(sa.add(9))                               # None
print(sa)                                      # {1, 2, 3, 34, 6, 7, 8, 41, 9, 12, 31}


# 删除操作
# remove 和 discard 的区别
sb = {1,2,3,4,5,6,7}
sb.remove(6)
print(sb)                                      # {1, 2, 3, 4, 5, 7}
sb.discard(6)
print(sb)                                      # {1, 2, 3, 4, 5, 7}
# 虽然输出结果相同，但remove删除的值如果不在集合中，会报错，而discard不会,看
sb.remove(8)
print(sb)                                      # KeyError: 8
sb.discard(8)
print(sb)                                        # {1, 2, 3, 4, 5, 7}

# pop弹出集合的一个内容
# 删除的内容是随机的
sb.pop()
print(sb)                                        # {2, 3, 4, 5, 7}


# 集合的数学操作
# intersection：交集
sc = {1,2,3,4,5,6,7,233,1234}
sd = {6,7,8,9,10}
print(sc.intersection(sd))                     #  {6, 7}
# difference: 差集
print(sc.difference(sd))                       #  {1, 2, 3, 4, 5, 233, 1234}
# 差集的另一种表达
print(sc - sd)
# union：交集
print(sc.union(sd))                            #  {1, 2, 3, 4, 5, 6, 7, 8, 233, 9, 10, 1234}
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

# set操作

# 集合set  集合关系测试
list_1=[1,4,5,7,3,6,7,9]
list_1=set(list_1)
print(list_1,type(list_1))
list_2=set([2,6,0,6,22,8,4])
print(list_2,type(list_2))
print("--------------------------------")

# 取交集
print("方法一")
print(list_1.intersection(list_2))
print("方法二")
print(list_1&list_2)
print("--------------------------------")

# 取并集
print("方法一")
print(list_1.union(list_2))
print("方法二")
print(list_1|list_2)
print("--------------------------------")

# 差集 in list_1 but not in list_2
print(list_1.difference(list_2))
print(list_1-list_2)
print("--------------------------------")

# 子集
list_3=[1,4,6]
list_4=[1,4,6,7]
list_3=set(list_3)
list_4=set(list_4)
print(list_3.issubset(list_4))
print(list_4.issuperset(list_3))
print("--------------------------------")

# 对称差集 把list_1与list_2互相都没有的元素放在一块，其实就是去掉重复元素
print(list_1.symmetric_difference(list_2))
print(list_1^list_2)
print("--------------------------------")

# 是否没有交集 Return True if two sets have a null intersection.
list_5=set([1,2,3,4])
list_6=set([5,6,7])
print(list_5.isdisjoint(list_6))
print("--------------------------------")

# 基本操作
# 添加一项
list_1.add('x')
print(list_1)

# 添加多项
list_1.update([10,37,42])
print(list_1)

# 删除一项
list_1.remove(10)
print(list_1)

# set长度
print(len(list_1))

# 测试9是否是list_1的成员
print(9 in list_1)

# pop()删除并且返回一个任意的元素
print(list_1.pop())

# 删除一个指定的值
list_1.discard('x')
print(list_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
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74