Python语法入门#

00 Why Python?#

Python是一门解释型语言，具有完全面向对象特性

01 What we need?#

解释器：Python本身(MS Store安装/自行安装) （Conda也算一种Python发行版）

IDE

02 变量#

Python的变量类型不同于C系的short long unsigned blbl 显得简单粗暴

但又有些不同于C的变量类型(又不简单粗暴了)

数字型

整型浮点型布尔型（True 1 / False 0) 复数型

非数字型

字符串 列表元组集合字典

变量定义#

变量的定义不需要声明，但是需要赋值才算创建

1
# 定义整型变量a
2
a = 10
3
# 定义字符串变量 hello
4
hello = "hello, world!"
5

6
'''
7
这是
8
一个
9
多行
10
注释
11
'''
12

13
'''
14
      3x -5 (x > 1)
15
f(x)= x + 2 (-1<=x<=1)
16
      5x +3 (x < -1)
17
'''
18

19
x = float(input('x = '))
20
if x > 1:
21
    y = 3 * x - 5
22
else:
23
    if x >= 1:
24
        y = x + 2
25
    else:
26
        y = 5 * x + 3
27
print('f(%.2f) = %.2f' % (x,y))
28

29

30
#转换输入类型为float 创建一个float型变量x

以上是一个分段函数求解程序输入x 得到 y

print部分有类似printf的格式化输出的处理。使用%将元组种的数值放到输出文段里

扩展： 我们其实有更现代的写法，

①将格式化段%.2f替换成{:.2f} ，将运算符%替换为.format

②仅适用于Python 3.6+

将输出段用双引号引起来，左端引号外加上f使其变为f-string，格式化段直接指向元组或变量

即{x:.2f} 或{y:.2f}

所以代码的最后一句可以写成下述格式：

1
print(f'f({x:.2f}) = {y:.2f}')

简洁很多

至于格式化输出段晚点再补充~

标识符#

标识符其实就是变量名 函数名

名字应当见名知意

可由字母 下划线 数字组成 不能数字开头不能与保留字重复

输出保留字的方法如下：

1
import keyword
2
print(keyword.kwlist)

列表(list)#

list是一种结构化的非标量类型，是值的有序序列

定义&遍历

1
list1 = [1, 3, 5, 7, 100]
2

3
# 乘号表示列表元素的重复
4
list2 = ['hello'] * 3
5
print(list2)  # ['hello', 'hello', 'hello']
6

7
# 计算列表长度（元素个数）
8
print(len(list1))  # 5
9

10
# 下标（索引）运算
11
print(list1[0])    # 1
12
print(list1[4])    # 100
13
print(list1[-1])   # 100
14
print(list1[-3])   # 5
15

16
# 通过循环用下标遍历列表元素
17
for index in range(len(list1)):
18
    print(list1[index])
19

20
# 通过 for 循环遍历列表元素
21
for elem in list1:
22
    print(elem)
23

24
# 通过 enumerate 函数处理列表之后再遍历可以同时获得元素索引和值
25
for index, elem in enumerate(list1):
26
    print(index, elem)

说人话的话这个东西就是数组pro max，它可以存字符串之类的变量

如果说列表相对数组pro在更灵活的变量类型的话，那它就max在相当简易的延长和删除上

1
list1 = [1, 3, 5, 7, 100]
2

3
# 修改元素
4
list1[2] = 300
5

6
# 添加元素
7
list1.append(200)         # 在末尾添加元素
8
list1.insert(1, 400)      # 在索引 1 的位置插入元素 400,即插入后位于list1[1]
9

10
# 合并两个列表
11
list1 += [1000, 2000]
12

13
print(list1)              # [1, 400, 3, 300, 7, 100, 200, 1000, 2000]
14
print(len(list1))         # 9
15

16
# 先通过成员运算判断元素是否在列表中，使用 remove 删除元素(甚至可以自动遍历整个列表找到符合要求的数值)
17
if 3 in list1:
18
    list1.remove(3)
19

20
# 删除指定位置的元素，可以返回被删除的元素
21
m = list1.pop(0)
22
print(f"被删除的第一个元素是：{m}")
23

24
# 清空列表元素
25
list1.clear()
26
print(list1)              # []

元组(tuple)#

tuple类似于列表重点在于不能修改

元组使用小括号()

定义与转换

1
t = ('CCNU', 1122, 'love', 77) #小括号在外 逗号分隔
2
print(t[2]) #查看元素
3
for member in t:
4
    print(member) #遍历元素
5

6
# 将元组转换成列表
7
list_t = list(t) # 是不是超级像c的强制类型转换呀
8

9
# 将列表转换成元组
10
l = ['CCNU', 77, 'love', 1122]
11
tuple_l = tuple(l)

集合(set)#

类似数学中的集合，元素不能重复

使用大括号{}括起来的叫集合

1
#定义集合
2
set = {1, 2, 3, 3, 3, 2} #可以写重复的 但是python会主动忽略
3
print(len(set)) # 3
4
 # 创建集合的构造器语法
5
set2 = set(range(1, 10)) # 理解为for(i=1;i<10;i++)
6
set3 = set((1, 2, 3, 3, 2, 1))
7

8
print(set2, set3) # {1, 2, 3, 4, 5, 6, 7, 8, 9} {1, 2, 3}
9

10
# 创建集合的推导式语法(推导式也可以⽤于推导集合)
11

12
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
13
# 仅存储3的倍数和5的倍数

同样的，元组、列表、集合可以相互转换，但是转换为集合会失去所有重复元素

TIP:集合为了保证效率，其顺序是不可控的，意味着每次对其进行修改之后都会得到不同的顺序（甚至不修改也有可能变动?这点存疑）

对集合的修改

1
set1.add(4) # 一次添加一个数值 已存在则忽略
2
set2.update([11,12]) # 一次添加多个 已存在则忽略
3
set2.discard(5) # 删除已有元素 如果不存在则忽略 不报错（remove会报错）
4

5
if 4 int set2:
6
    set2.remove(4)
7

8
print(set3.pop())# 随机删一个
9
print(set3)

集合运算

1
# 集合交并差 对称差
2
print(set1 & set2)# print(set1.intersection(set2)) 交集 同时存在的元素
3
print(set1 | set2)# print(set1.union(set2)) 并集
4
print(set1 - set2)# print(set1.difference(set2)) 差集 属于set1但不属于set2的元素
5
print(set1 ^ set2)# print(set1.symmetric_difference(set2)) 属于set1或set2，但不同时属于set1或set2的元素（排除交集的并集)
6

7
# 判断子集或者超集
8
# 如果是，则运算返回一个True/1的bool 否则返回一个False/0
9

10
print(set2 <= set1) # print(set2.issubset(set1)) set2是否为set1的子集
11
print(set2 >= set1) # print(set2.issuperset(set2)) set2是否为set1的超集
12
print(set2 < set1) # set2是否为set1的真子集
13
print(set2 > set1) # set2是否为set1的真超集

字典（dict）#

dict的每个元素都是由一个键和一个值组成的键值对，键与值通过冒号分开

1
# 创建字典字面量
2
scores = {'张三': 95, '李四': 85, '王五': 35}
3

4
#创建字典的构造器语法
5
items1 = dict(one=1, two=2, three=3, four=4) #{'one': 1, 'two': 2, 'three': 3, 'four': 4}
6

7
# zip函数将两个序列压成字典
8
item1 = dict(zip(['a', 'b', 'c'], '123')) #{'a': '1', 'b': '2', 'c': '3'}
9

10
#推导式语法
11
items3 = {num: num ** 2 for num in range(1, 10)} #对应平方
12

13
 print(scores['张三']) # 95
14
 print(scores['李四']) # 85
15
# 遍历键值
16
for key in scores:
17
    print(f'{key}:{scores[key]}')
18

19
'''
20
张三:95
21
李四:85
22
王五:35
23
'''
24

25
#更新元素
26
scores['张三'] = 88 #修改已有项
27
scores['ykn'] = 66 #添加新的键值对
28
scores.update(nina = 27, mmk = 0) #添加多个键值对
29
print(scores) # {'张三': 88, '李四': 85, '王五': 35, 'ykn': 66, 'nina': 27, 'mmk': 0}
30

31
# get方法 获取值 但可以设置默认值（即不存在对应键值对则返回设定的默认值）
32
print(scores.get('drum'. 486))
33
print(scores.pop('anon',250) #删除对应键值对并返回对应值，若不存在则返回设定的默认值。若未提供默认值抛出KeyError
34

35
print(scores.popitem()) # 随机删除并返回一个键值对 Python 3.7+中此函数默认删除最后插入的键值对

函数#

通过函数名封装并调用一段实现功能的完整代码

内置函数 print() input()之类包含于库中

自定义函数

1
def func_name (parameter1, parameter2): #定义函数名和参数
2
    ... #此处为具体代码段
3
    return s # 返回值(可选)

调用时使用func_name(para1, para2)，需要匹配传入参数

类（Class)#

类是面向对象特性的重要元素。我们学的C语言很显然没有类的概念，现在在python中我们会通过Class来理解面向对象特性