1.运算符

1）数学运算符：+， *

• 列表1 + 列表2 -> 产生一个新的列表，新列表中的元素是两个列表中所有元素的合并

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

• 列表 * N 或者 N * 列表 -> 列表中的元素重复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 == li2)
print(li1 is li2)   # print(id(li1) == id(li2))

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

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

2.in和not in

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

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

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, 91, 12]
print(max(scores))  # 91
print(min(scores))  # 12

scores = [23, '100', 90, '23']
# print(max(scores))  # TypeError: '>' not supported between instances of 'str' and 'int'

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

scores = [23, 89, 89, 78, 90, 91, 12]
print(sum(scores))
print(sum(range(101)))

• 4）list
  list（数据） -> 将指定的数据转换成列表；数据必须是序列（所有的序列都可以转换成列表）

# print(list(100))  # TypeError: 'int' object is not iterable
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)

3.列表.index（元素） -> 获取指定元素在列表中的下标（下标值是0~长度-1）

• a.如果元素不存在会报错

nums = [10, 3, 50, 3, 90]
# print(nums.index(100))  # ValueError: 100 is not in list

• b.如果元素有多个,取从左到右第一个指定元素的下标

print(nums.index(3))  # 1

4.列表.reverse（） -> 将原来的列表倒叙（反过来）

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

nums = [1, 9, 3]
new_nums = nums[::-1]
print(nums, new_nums) # [1, 9, 3] [3, 9, 1]

5.列表.clear（） -> 清空

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

nums = [10, 3, 50, 3, 90]
nums = []
print(nums)
# 相比于直接赋值一个空的列表，clear的执行效率更高，因此清空列表一般用clear，而不是直接赋值[]

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

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

heros = ['后羿', '甄姬', '凯', '庄周', '蔡文姬']
heros2 = heros
del heros2[-1]
print(heros2)  # ['后羿', '甄姬', '凯', '庄周']
print(heros)   # ['后羿', '甄姬', '凯', '庄周']
# 采用上述的复制列表操作时，对heros2列表进行增、删、改的操作时，heros列表也会发生变化
# 实时编程网站：pythontutor.com
heros = ['后羿', '甄姬', '凯', '庄周', '蔡文姬']
heros2 = heros.copy()
del heros2[-1]
print(heros2)  # ['后羿', '甄姬', '凯', '庄周']
print(heros)   # ['后羿', '甄姬', '凯', '庄周', '蔡文姬']
# copy操作和切片操作都会产生新的列表

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

• 列表.sort（reverse=True） -> 将列表中的元素从大到小排序（直接修改列表元素的顺序，不会产生新的列表）
• 列表.sort（reverse=True） 相当于 列表.sort() ; 列表.reverse()

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

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

8.排序函数：sorted（序列） -> 不修改原序列，排序后产生一个新的列表（从小打大，升序），返回值是列表

sorted（序列,reverse=True） -> 降序

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

str1 = 'hello'
new_str1 = sorted(str1)
print(new_str1)  # ['e', 'h', 'l', 'l', 'o']
# 列表.reverse和reversed 可以参照 列表.sort和sorted（序列）
# reversed（序列） -> 将序列中的元素倒序，产生一个新的序列对应的迭代器（先做了解）

                                            立ち入り禁止

坑一：直接遍历元素删除满足条件的元素 -> 因为遍历的时候列表中的元素取不完，导致删不干净

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]
2 num = 90: 90<60  ->  scores = [89, 45, 90, 34, 54, 20, 90]
3 num = 34: 34<60  ->  scores = [89, 45, 90, 54, 20, 90]
4 num = 20: 20<60  ->  scores = [89, 45, 90, 54, 90]
5 循环结束！
"""

# 解决坑一：保证遍历过程中能够把需要删除的列表中的元素全部取完
scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
t_scores = scores.copy()  # 或者 t_scores = scores[:]
for num in t_scores:
    if num < 60:
        scores.remove(num)
print(scores)
# 简化
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]
length = len(scores)
for index in range(length):
    if scores[index] < 60:
        del scores[index]
print(scores)
"""
index =
scores = [34, 89, 56, 45, 90, 34, 54, 20, 90]
length = len(scores) = 9
index = 0: 34 <60 -> del scores[0],scores = [89, 56, 45, 90, 34, 54, 20, 90]
index = 1: 56 <60 -> scores = [89, 45, 90, 34, 54, 20, 90]
……
index = 5: IndexError: list index out of range
"""
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
    index += 1
print(scores)

                                            立ち入り禁止

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

tuple1 = (1, 2, 3)
print(type(tuple1))

2.查

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

tuple2 = (10, 30, 31, 70)
print(tuple2[-1])
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'))

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

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

list1 = [10]
print(list1, type(list1))
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)
# x, y = (10, 20) -> x, y = 10, 20

• 4)同时声明多个变量获取元组中的元素，变量的个数可以比元组中元素的个数少，但是这个时候,多个变量中的某一个变量的前面必须加；带的变量可以获取不带*的变量获取完剩下的部分。

tuple5 = (10, 20, 299, 19, 230)
x1, x2, x3, x4, x5 = tuple5
x1, *x2, x3 = tuple5
print(x1, x2, x3)  # 10 [20, 299, 19] 230

                                            立ち入り禁止

import math # 数学模块 - 提供数学相关方法和数据
import cmath # 和复数相关的数学模块

python中和数字相关的类型主要有四种：整型（int）、浮点型（float）、布尔（bool）、复数（complex）

• 1.整型（int） - 所有整数对应的类型（python2.x中，整型除了int还有long）；支持2进制、8进制和16进制的表示方式
  int(数据) - 将指定的数据转换成整数；
  - 1）所有的浮点数和布尔都可以转换成整型（取整）
  - 2）字符串，字符串去掉引号后本身是一个整数

print(int(12.5))
print(int(-12.5))
print(int(True), int(False))
# print(int('abc'))   # ValueError: invalid literal for int() with base 10: 'abc'
print(int('12'))

• 2.浮点型（float） - 所有带小数点的数对应的类型；支持科学计数法：3e4 == 310*4
  float（数据） - 将指定的数据转换成浮点数
  - 1）所有的整数和布尔都可以转换成浮点数
  - 2）字符串，字符串去掉引号后本身就是一个数字

print(float('2e3'))
print(3e4)
print(type(3e4))

• 3.布尔（bool） - 只有True和False；True本质就是1，False本质就是0
  bool（数据） - 将指定数据转换成布尔值；
  不管什么类型的数据都能转换成布尔，所有为零为空的值会转换成False，其他都是True

print(True + 1)
print(bool(0), bool(0.0), bool(''), bool([]), bool(()), bool(None))
print(bool(' '))
list1 = [1, 2]
if list1:
    print('======')

num = 10
if num & 1:
    print('++++++')

if not list1:
    print('list1为空')

• 4.复数（complex） - 由实部和虚部组成的数就是复数，实部 + 虚部j；python直接支持复数的运算
  注意：如果虚部是1，这个1不能省

c1 = 10 + 2j
c2 = 5 - 3j
print(c1 + c2)
print(c1 - c2)
print(c1 * c2)

• 5.数学模块

math.pi
math.floor()  # 向下取整
math.fabs()  # 求绝对值,结果为浮点型
abs()  # 求绝对值，结果的数据类型与原数据的数据类型相同