day6-列表、元组、数字

===============列表相关操作===============

1.运算符

1）数学运算符：+，*

列表 + 列表 -> 产生一个新的列表，新列表中的元素是两个列表中元素的合并

list1 = [1, 2, 3]
list2 = ['张三', '李四']
print(list1 + list2)

列表 * Number， Number * 列表 -> 列表中的元素重复N次，产生一个新的列表

print(list1 * 3)

2）比较运算：

== ， !=

列表1 == 列表2 ->判断两个列表的值是否相等

list3 = [1, 2, 3]
list4 = [2, 1, 3]
print(list3 == list4)  # False

list4 = [1, 2, 3]
print(list3 == list4)  # True

is

变量1 is 变量2 -> 判断地址是否相同

li1 = [1, 2]
li2 = [1, 2]
print(li1 is li2)  # print(id(li1) == id(li2))

>,<,>=,<=（了解）

print([1, 2, 3] > [10, 200])   # False

2.in和not in

元素 in 列表 -> 判断列表中是否存在指定元素
元素 not in 列表 -> 判断列表中是否不存在指定元素

names = ['小明', '小红', '小花', '张三']
print('小红' in names)
print('李四' in names)

3.相关函数:len、max、min、list、sum

1）len（序列） - 获取序列的长度（元素的个数）

print(len([1, 2, 3]))
print(len('hello'))

2）max/min

max(序列)/min(序列) -> 获取序列中元素的最大值/最小值

序列的要求：a.序列中所有的元素类型一致(数字看成一种类型)

b.元素本身支持比较大小

scores = [23, 89, 89, 78, 90, 97, 12]
print(max(scores))
print(min(scores))

3）sum

sum（数字列表） -> 求数列中所有元素的和

scores = [1, 2, 3]
print(sum(scores))
print(sum(range(101)))

4）list

list(数据) -> 将制定的数据转换成列表；数据必须是序列

print(list('hello'))    # ['h', 'e', 'l', 'l', 'o']
print(list(range(10, 15)))    # [10, 11, 12, 13, 14]

===============列表相关方法===============

names = ['赵云', '小乔', '小乔']

1.列表.count(元素) -> 统计列表中指定元素的个数

print(names.count('赵云'))  # 1
print(names.count('大乔'))  # 0
print(names.count('小乔'))  # 2

2.列表.extend(序列) - 将序列中的元素全部添加到列表中

names.append('后裔')
print(names)
names.extend('后裔')
print(names)
names.append([1, 2])
print(names)
names.extend([1, 2])
print(names)

列表.index(元素) -> 获取指定元素在列表中的下标

如果元素不存在会报错

如果元素有多个获取第一个

nums = [10, 3, 50, 3, 90]
print(nums.index(3))
print(nums.index(50))

4.列表.reverse() -> 将原来的列表倒序(反过来)

nums = [1, 9, 3]
nums.reverse()
print(nums)

5.列表.clear() -> 清空列表

nums = [1, 2, 3, 4, 5]
nums.clear()
print(nums)

注意:清空列表用clear，而不是直接赋值为[]

nums = [1, 2, 3, 4, 5]
nums = []
print(nums)

6.列表.copy（） -> 复制列表中的元素，产生一个新的列表,将新列表的地址返回。赋值后两个相互不影响

和列表[:]的功能一模一样，都属于浅拷贝

heros = ['后裔', '甄姬', '凯', '庄周', '蔡文姬']
heros2 = heros.copy()
print(heros2)
heros2.reverse()
print(heros2)
print(heros)

7.列表.sort() -> 将列表中的元素从小到大排序(直接修改列表元素的顺序，不会产生新的列表)

列表.sort(reverse=True) -> 将列表中的元素从大到小排序

列表.sort(reverse=True) == 列表.sort();序列.reverse

scores = [89, 78, 90, 56, 76, 30]
scores.sort()
print(scores)
scores.sort(reverse=True)
print(scores)

8.排序函数:sorted(序列) -> 不修改原序列，从小到大排序后产生一个新的列表

sorted(序列，reverse=True) -> 不修改原序列，排序后产生一个新的从大到小列表

scores = [89, 78, 90, 56, 76, 30]
newscores = sorted(scores)
print(newscores)

str1 = 'hello'
newstr1 = sorted(str1)
print(newstr1)

===============遍历删除===============

坑1： 直接遍历元素删除满足条件的元素 -> 因为取不完

scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
for num in scores:
    if num < 60:
        scores.remove(num)
print(scores)

scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
0 num = 34  ->  34<60  ->  scores = [89, 56, 45, 90, 34, 54, 20, 90]
1 num = 56  ->  56<60  ->  scores = [89, 45, 90, 34 ,54 ,20, 90]
......

解决坑1：保证遍历过程能够把需要删除列表中的元素全部取完

scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
t_scores = scores[:]
for num in t_scores:
    if num < 60:
        scores.remove(num)
print(scores)

坑2：

scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
# lenght = len(scores)
# for index in range(lenght):
#     if scores[index] < 60:
#         del scores[index]
# print(scores)

scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
index = 0
while index < len(scores):
    if scores[index] < 60:
        del scores[index]
        continue
    index += 1
print(scores)

===============元组===============

1.什么是元组（tuple）

元组就是不可变的列表
元组是容器型数据类型，将（）作为容器的标志，里面多个元素用逗号隔开：（元素1，元素2，元素3.....）
元组不可变（不支持增删改操作），有序（支持下标操作）
元素可以是任何类型的数据

tuple1 = (1, 2, 3)

2.查

1)获取元素

列表获取元素的操作元组都支持

tuple2 = (10, 30, 21, 70)
print(tuple2[-1])
print(tuple2[2:])  # (21, 70)

2）相关原运算：+，*，==，!=，is，in，not in，len，max，min，sum，sorted

print((1, 2, 3) + ('abc', 'hello'))
print((1, 2, 3) * 3)

tuple(数据) - 将数据转换成元组（数据必须是序列）

print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')

3.元组特有或使用频率偏高的操作

1）单个元素的元组:(元素，)

tuple3 = (10,)
print(tuple3, type(tuple3))

2）单独使用的元组的值,()可以省略 -> 多个数据用逗号隔开表示的还是一个元组

tuple4 = 10, 20, 30
print(tuple4, type(tuple4))

3）可以通过让变量的个数和元组中元素的个数保持一致来分别获取元组中的元素

变量1，变量2，变量3，..... = 元组

tuple5 = 10, 20
x, y = tuple5
print(x, y)

4）同时声明多个变量获取元组中的元素，变量的个数可以比元组中元素的个数少，

但是这个时候多个变量中的某一个变量前面必须加；带的变量可以获取不带*的变量获取完剩下的部分

tuple5 = (10, 20, 299, 19, 230)
z, *x, y = tuple5
print(z, x, y)

===============数字===============

python中和数字相关的类型：整型(int)、浮点型(float)、布尔(bool)、复数(complex)

1.整型(int) - 所有整数对应的类型；支持2进制，8进制，16进制的表示方式

int(数据) - 将指定的数据转换为整数;

1)所有的浮点数和布尔都可以转换为整型

2)字符串,字符串去掉引号后本身是一个整数

print(int(12.5))  # 12
print(int(-12.5))  # -12
print(int('123'))  # 123

2.浮点型(float) - 所有带小数点的数对应的类型；支持科学计数法：3e4 == 310*4

float(数据) - 将指定的数据转换成浮点数

1)所有整数和布尔都可以转换成浮点

2)字符串,去掉一个引号后本身是一个数字

print(3e4)
print(float(100))  # 100.0
print(float('12.5'))  # 12.5
print(float(2e3))  # 2000.0

3.布尔(bool) - 只有True和False；True本质就是1，False本质就是0

bool(数据) - 将指定数据转换成布尔值；

1)不管什么类型的数据都能转换成布尔；所有为0和为空的值会转换成False，其他都是True

print(True + 1)   # 2
print(False + 10)   # 1
print(False * 3)   # 0
print(bool(0), bool(0.0), bool(''), bool([]), bool(None))
list1 = [1, 2]
if list1:
    print('list1不为空')
if not list1:
    print('list1为空')

num = 11
if num & 1:
    print('奇数')
if num & 1 == 0:
    print('偶数')

4.复数(complex) - 由实部和虚部(j)组成的数就是复数，实部+虚部j;python直接支持复数的运算

注意：如果虚部是1，这个1不能省

c1 = 10 + 2j
c2 = 5 - 3j
print(c1 + c2)   # 15-1j
print(c1 - c2)   # 5+5j
print(c1 * c2)   # 56-20j