python基础语法：

"""
1.注释
2.标识符：a.由字母数字下划线组成，python3中可以是中文。b.数字不能开头。c.大小敏感
3.行与缩进：python中对缩进有严格的要求
4.多行显示：加反斜杠
5.python中的基本数据类型：整型(int)、浮点型(float)、布尔(bool)、字符串(str)等
"""

abc = 10
b = 20
'name'
sum1 = 100 + 23333333 + abc\
       + 82973940712982738 + 90

变量的声明

"""
1.变量名 = 值
2.变量名:标识符，不能是关键字；PEP8:(字母全部小写，多个单词之间用下划线隔开)，见名知义
3.声明变量的写法
4.声明变量/给变量赋值的原理
"""

a = 100
a = b = c = 'abc'
a = 100; b = 200
a, b = 10, 20  # 元祖

运算符

"""
+，-，*，/,%, //, **

, <, ==，!=, >=, <=
and, or, not
=, +=, -=, *=, /=, %=, //=, **=
运算符的优先级：可以通过加括号改变运算顺序
"""

字符串

"""
1.字符串长什么样
2.字符编码(Unicode), chr(), ord()
3.获取单个或者部分字符:字符串[index], 字符串[下标1:下标2:步进]
4.运算：+, *, 比较运算, in, not in, len()
5.相关的方法
"""

分之

"""
1.if 条件语句:
执行语句

2.if 条件语句:
执行语句1
else:
执行语句2

3.if-elif-else
elif 条件语句:
"""

循环结构

"""
1.for循环
for 变量名 in 序列:
循环体
else:

执行过程:

2.while循环

while 条件语句:
循环体
else:

执行过程:

3.break, continue, else
break和continue写在循环体中的
else写在循环外的。循环里面遇到break，else中的语句不会执行
"""
"""author = 余婷"""

"""
list(列表)
列表是python中的容器类型。有序的，可变的容器(可变指的是列表中的元素和元素的位置、个数可变)。
有序 -> 可以通过下标来获取元素
可变 -> 可以进行增删改(查)

元素：指的是列表中的每一个内容。列表中的元素可以是任意类型的数据

"""

1.列表的声明

a.声明变量赋一个列表的值
声明了一个列表，列表中有5个元素，分别是90，80，97，67，55

scores = [90, 80, 97, 67, 55]
print(scores, type(scores))

声明了一个列表，列表中有3个元素，分别是'余婷',18,'女' （一个列表中的元素的类型可以不一样）

person = ['余婷', 18, '女']
print(person)

name = '王海飞'
age = 20
person2 = [name, age, '男']
print(person2)

[] --> 代表空列表
names = []
print(names, type(names))

b.将其他的数据类型转换成列表(只有序列才能转换：字符串和range,字典、元祖、集合、生成式和迭代器)
chars = list('abcdef')
print(chars)

numbers = list(range(10))
print(numbers)

1.查: 获取列表元素

a.获取单个元素：列表[下标]
下标范围:0 ~ 元素个数-1 或者 -1 ~ -元素个数
注意: 下标不能越界

tv_names = [10, '琅琊榜', '甄嬛传', '生活大爆炸', '尼基塔']
print(tv_names[0])
print(tv_names[1])
print((tv_names[-1]))
 print(tv_names[10])  # IndexError: list index out of range

b.获取部分元素(切片): 列表[下标1:下标2] / 列表[下标1:下标2:步进]
从下标1开始获取下标2前为止(注意：下标2对应的值是取不到)
步进值是正的就从前往后取，步进是负的就从后往前取
结果是列表;这儿的下标可以越界
print(tv_names[1:3]) # ['琅琊榜', '甄嬛传']
print(tv_names[-1:-4:-1]) # ['尼基塔', '生活大爆炸', '甄嬛传']
print(tv_names[:4]) # ['请回答1988', '琅琊榜', '甄嬛传', '生活大爆炸']
print(tv_names[3:]) # ['生活大爆炸', '尼基塔']
print(tv_names[:]) # ['请回答1988', '琅琊榜', '甄嬛传', '生活大爆炸', '尼基塔']

c.遍历(一个一个的获取每个元素)
可以将列表直接放到for循环的in的后边。
循环过程中，for后面的变量取的是列表中的每个元素
for item in tv_names:
print(item)

练习:写一个列表来保存一个班的学生的成绩(6个)，统计班上成绩在80分以上人的个数
scores = [89, 90, 67, 65, 81, 78]
count = 0 # 统计个数
for score in scores:
if score > 80:
count += 1
print(count)

2.改(修改元素的值)
语法: 列表名[下标] = 新值 （通过下标获取元素，然后重新赋值）# 注意：下标不能越界
person = ['小明', 35, '乒乓球']

修改person列表中下标是1的元素的值，修改为25
person[1] = 25
print(person)

person[2] = '篮球'
print(person)

person[3] = '男' # IndexError: list assignment index out of range

3.增(增加列表的元素,添加元素)
注意: 列表中元素的个数发生改变后，列表中每个元素的下标会根据新的位置重新分配
a.列表.append(元素) : 在列表的最后去添加一个元素
person.append('男')
print(person)

person.append(80)
print(person)

b.列表.insert(下标,元素) : 在指定的下标前插入一个元素
person.insert(0, '001')
print(person)
print(person[1])

person.insert(2, 'H5')
print(person)

练习：录入(输入)5个学生的成绩，并且保存在一个列表中

 scores = []
 for _ in range(5):
     score = input("请输入学生的成绩:")
     scores.append(int(score))

 print(scores)
"""
scores = []
_ = (0,1,2,3,4)
_ = 0   score = 20  [20]
_ = 1   score = 80  [20, 80]

...
"""

4.删(删除列表中的元素)
a. del 列表[下标] ---> 根据下标去删除列表中的元素
del 语句是python中删除数据的语法，它可以删除任何数据: del 变量(删除变量) del 列表(删除整个列表)
foods = ['辣条', '棒棒糖', '大蒜', '火锅', '饼干', '小龙虾', '大虾', '花甲']
del foods[2] # 删除下标是2的元素
print(foods)

del foods[4]
print(foods)

b. 列表.remove(元素) ---> 删除列表中的某个值
注意：如果这个元素在列表中有多个，只删除最前面的那一个
foods.remove('饼干')
print(foods)

c. 列表.pop(下标) ---> 将列表中指定下标对应的元素取出来
food = foods.pop(1) # 将foods中下标是1对应的元素取出来，保存到变量food中
print(foods, food)

练习：想尽一切办法，将一个保存成绩的列表中，成绩低于60分的全部删除
[78, 59, 40, 90, 89, 45, 69, 30] --> [78, 90, 89, 69]

scores = [78, 59, 40, 90, 89, 45, 69, 30]
for score in scores[:]:
    if score < 60:
        scores.remove(score)
print(scores)

注意：以后遍历列表的元素的时候，我们一般遍历它的拷贝的值([:])
"""

scores = [78, 90, 89, 69]
[:] = [78, 59, 40, 90, 89, 45, 69, 30]

"""

4. python中，变量在存数据的值的时候，会根据数据类型的不同，使用两种方式来存值

"""
值类型：变量存数据直接存值，例如：整型、浮点型、布尔、字符串
引用类型：变量存数据的时候，存的是数据在内存中的地址。例如：列表、字典、元祖、集合、函数、自定义的类的对象等！
"""
a = 10
b = a
print(a, b)
a = 100
print(a, b)

a1 = [1, 2]
引用类型赋值的时候赋的是地址
b1 = a1

先将列表a1中的元素拷贝一份存到一个新的地址中，然后把新的地址赋给c1
c1 = a1[:]
print(a1, b1)

a1.append(100)
print(a1, b1,c1)

5. 1. +操作

列表1 + 列表2：将列表1中元素和列表2中的元依次合并，产生一个新的列表

a = [1, 2]
list1 = a + ['abc', 100]
print(list1, a)

2. • 操作
     列表1 * N：将列表1中元素重复N次，产生一个新的列表

list2 = a * 3
print(list2)   # [1, 2, 1, 2, 1, 2]

3. in / not in
   元素 in 列表 : 判断一个元素是否在列表中

print(10 in [1, 2, 3, 4, 10])

4. 求列表的长度
   len(序列)

print(len([1, 2, 3]))
names = ['海贼', '一拳超人', '一人之下', '进击的巨人']
print(len(names))

5.相关的方法
numbers = [1, 20, 3, 56, 1, 34, 100, 1, 1]

5.1 列表.count(元素) ：统计指定的元素在指定列表中有几个
print(numbers.count(1))

5.2 列表.extend(序列) : 将序列中的元素添加到列表中

 numbers.extend([100, 200])
numbers.extend('abc')
print(numbers)

 numbers.append([100, 200])
print(numbers)

5.3 列表.index(元素) : 获取指定元素对应的第一个下标

index1 = numbers.index(20)
print(index1)

5.4 列表.pop() : 将列表中的最后一个元素从列表中取出来

item = numbers.pop()
print(item, numbers)

5.5 列表.reverse() : 将列表中的元素反序

numbers = [1, 20, 3, 40, 5]
numbers.reverse()
print(numbers)

5.6 列表.sort(): 对列表元素进行排序(默认是升序)
列表.sort(reverse=True): 对列表元素进行降序排序

numbers.sort(reverse=True)
print(numbers)

5.7 列表.clear(): 将列表中的元素全部清除

numbers.clear()
print(numbers)

5.8 列表.copy(): 将列表中的元素全部拷贝一份产生一个新的列表，相当于列表[:]。
注意：这儿的拷贝是浅拷贝

numbers = [1, 2, 3, 4]
numbers2 = numbers.copy()
print(numbers2)

"""author = 余婷"""
import copy

总结：

"""
浅拷贝：只是单纯的将值拷贝（如果是对象就直接拷贝对象的地址）
深拷贝：会拷贝对象地址对应的值，产生一个新的地址，然后将新的地址进行赋值
"""

numbers1 = [1, 2]
numbers = [numbers1, 3, 4, 'abc']

/浅拷贝

new_numbers = numbers.copy()

/深拷贝

new_numbers2 = copy.deepcopy(numbers)

numbers1.append(100)
print(new_numbers)
print(new_numbers2)

 numbers.remove('abc')
print(new_numbers)

tuple(元祖)

元祖就是不可变的列表。列表中除了和可变相关的内容以外，其他的全部适用于元祖
不支持增、删除、修改，只支持和查相关的操作

1.声明元祖

tuple1 = (1, 2, 'abc', True, [1, 2])
print(tuple1, type(tuple1))

注意：如果要写一个元祖元素个数是1的字面量，需要在那一个元素的后面加逗号

t2 = (100,)
print(t2, type(t2), len(t2))

() --> 空的元祖

t3 = ()
print(t3, type(t3))

2.查相关的

t3 = ('red', 'yellow', 'green', 'pink')
print(t3[2])
print(t3[0:3])

for item in t3:
    print(item)

3.特殊操作

point = (100, 200, 'red')
print(point[0], point[1])

通过两个变量来获取元祖中的唯一的两个元素的值

x, y, color = point
print(x, y)

通过在变量前加*,获取元祖/列表中的一部分元素值，结果是一个列表

user = ('小吕', 90, 98, 56, 100, '男')
name, *score, sex = user
print(name, score, sex)

user2 = ('小红', 90, 100, 89, 67, 78)
name, *score = user2
print(name, score)

*score, name, sex = (89, 98, 78, 67, '小蓝', 'boy')
print(score, name, sex)

4.多个值之间用逗号隔开，对应的数据也是元祖

a = 1, 2, 3, 4    # 相当于 a = (1, 2, 3, 4, 5)
print(a,  type(a))

x, y = 100, 200  # 相当于x,y = (100, 200)
print(x, y)

7.输出9*9口诀。 1.程序分析：分行与列考虑，共9行9列，i控制行，j控制列。

xy
x: 每一行从1 ~ 行数
y: 就是行数
for y in range(1, 10):
for x in range(1, y + 1):
print('%dx%d=%d' % (y, x, yx), end=' ')
换行
print()