python基础语法记录

基本语法

标识符

同大多数语言一样,python有着一下特点:

  1. 第一个字符必须是字母表中字母或下划线 _ 。
  2. 标识符的其他的部分由字母、数字和下划线组成。
  3. 标识符对大小写敏感。
  4. 不能用保留字(即关键字)用作任何标识符名称

注释

单行注释用“#”
多行注释用’’’和”””

1
2
3
4
5
6
7
8
# 单行注释
print("Hello world!")# 单行注释
'''
多行注释
'''
"""
多行注释
"""

代码块的表示方法

与其他语言不同的是,python使用缩进来表示代码块,不需要用大括号{},具有相同缩进的相邻语句会视为上下文。

多行语句

由于python用缩进表示代码块,如果不采用特殊的表示方法,一个语句就只能写在逻辑上的一行。这对于长语句不友好,于是我们规定反斜杠\可以用来实现多行语句

1
2
3
4
5
total = item_one + \
item_two + \
item_three
#等价于
total = item_one + item_two + item_three

值得注意的是特殊语句如:[],{},()中的多行语句,无需反斜杠
1
2
total = ['item_one', 'item_two', 'item_three',
'item_four', 'item_five']

数值数据类型

Python中每个对象都有一个数据类型,数据类型定义为一个值的集合以及定义在这个值集上的一组运算操作。一个对象可执行且只允许执行其对应数据类型所定义的操作。
Python中有6个标准的数据类型:number,string,list,tuple,dictionary,set

number

python包括4种内置的数值数据类型

  1. int
  2. float
  3. bool
  4. complex

string

与其他语言不同的是,python并没有单独的字符类型(例如C中的char),单独的字符在python中会被视作是一个长度为1的字符串。
字符串的创建:

1
2
3
4
5
6
7
var1 = 'Hello World!' #单引号创建
var2 = "nihao" #双引号
#三引号创建
var3 ="""ni
hao
ya
"""

同大多数语言一样,python支持转义字符
若不想字符串中的转义字符生效,即需用r或R来定义原始字符串
1
2
str1="hello\nworld"
str2=r"hello\nworld"

字符串运算符:

1
2
3
4
5
6
7
8
9
10
a = "Hello"
b = "Python"
# +字符串连接
print("a + b 输出结果:", a + b)
# *重复输出字符串
print("a * 2 输出结果:", a * 2)
# []通过索引获取字符串中字符
print("a[1] 输出结果:", a[1])
# [:]截取字符串中的部分
print("a[1:4] 输出结果:", a[1:4])

字符串的格式化:
类似于C语言中printf,以下是其示例:
1
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

一些参数声明:

符号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写)
%f 格式化浮点数字,可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e,用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
在正数前面显示空格
# 在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0 显示的数字前面填充’0’而不是默认的空格
% ‘%%’输出一个单一的’%’
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

字符串对象的format方法的格式化输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'''
格式为str.format()
"···{field_name:format_spec}···"
field_name为字段名称
format_spec则描述格式
格式为[[fill]align][sign][0][width][,][.precision][type]
'''
"Hello,{}".format("cat")
# 花括号内部可以写上待输出的目标字符串的索引
print("{0}+{1}={2}".format(1,2,3))
print("{1}+{0}={2}".format(1,2,3))
# 也可以用关键字
print("{a}+{b}={c}".format(a="cat",b="isher",c="catisher"))
# 属性也可以
print("{0.real}+{0.imag}={0}".format(3-5j))
# 下标索引也行
print("{0[0]}+{0[1]}={0[2]}".format([1,2,3]))

f-string
这个是python3.6之后版本添加的语法,是一种新的格式化字符串语法
f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去,实例如下:

1
2
3
4
5
>>> name = 'min'
>>> f'Hello {name}' # 替换变量
'Hello min'
>>> f'{1+2}' # 使用表达式
'3'

用了这种方式明显更简单了,不用再去判断使用 %s,还是 %d。

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果:

1
2
3
4
5
6
>>> x = 1
>>> print(f'{x+1}') # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
x+1=2

列表

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
# 列表的创建方法
list1=list()
list2=list("hello")
list3=[]
list4=[1,2,3]

# 列表的截取
a=list4[2:4] #[begin:end]从begin开始到end结束,不包括end
b=list4[-1] #索引为负数时从后往前数

# 列表的修改
x=[1,2,3,4,5]
x[0]=2
x[5:]=[6]
name=list('perl')
name[1:]=list('ython')

# 列表中间插入
number=[1,6]
number[1:1]=[2,3,4,5]

#列表中删除元素
del number[1]
#删除列表
del number

元组

1
2
3
4
5
6
7
8
9
10
11
# 创建元组
tup=() #空元组
tup=(1,) #只有一个元素时要加上逗号,否则括号就会当做运算符使用
tup=tuple([1,2,3]) #通过构造方法可以将列表、集合、字符串转换成元组
A=1,2,3,"1",1+3j #任意无符号的对象,以逗号隔开,会被默认视作为元组

#修改元组
tuple1=tuple2+tuple3 #元组属于不可变序列,元素不可修改,但我们可以通过拼接的方式得到新元组

#删除元组
del tuple1
元组之间的比较

元组之间可以进行比较,比较的规则是逐个比较元组中的元素。首先比较第一个元素,如果相等,则比较第二个元素,以此类推。如果所有元素都相等,那么元组相等;否则,比较的结果取决于第一个不相等元素的比较结果。

字典

字典属于是无序的对象集合,元素是通过键来存储的,而不是通过偏移存取的。字典中的键必须使用不可变类型数据,且在同一个字典中,“键”必须是唯一的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#创建字典
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }
emptyDict = {}
emptyDict = dict()

#添加元素
tinydict = {}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
#修改元素
tinydict['Age'] = 7

#删除元素
del tinydict['Age']
tinydict.pop('School') #pop()方法可以删除指定字典元素并返回该键所对应的值
tinydict.clear() #该方法清除所有元素,形成空列表

#删除字典
del tinydict

集合

集合属于是无序可变序列,用{}作为界定符,集合之中不可有可变元素

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
#创建集合
set1=set("hello") #不能用 set1={"hello"},{}被指定于创建字典

#添加元素
set1.add('a')
set1.update(['d','s','f']) #该方法添加多个元素

#删除元素
set1.discard('a') #若集合中不存在指定元素时,集合保持不变
set1.remove('a') #若集合中不存在指定元素时,会引发KeyError
a=set1.pop() #该方法是从左边删除集合中的元素并返回删除的元素

#集合的运算
A={1,2,3,4,5,6,7}
B={0,3,4}
#取交集
A&B
A.intersection(B)
#取并集
A|B
A.union(B)
#取差集
A-B
A.difference(B)
#取对称差集
A^B
A.symmetric_difference(B)
#判断是否为子集
A<B
A.issubset(B)

数据类型转换

函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

for循环结构

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
'''
for循环的语法格式
for 控制变量 in 可遍历序列:
循环体
for循环可作用于迭代容器对象中的元素,例如列表、元组、字典、集合、文件等等,甚至可以是自定义类或者函数
'''

#for循环作用于列表
a=[1,2,3,4,5]
for i in a:
print(i)
#大概就这个格式

#for循环作用于字符串
str1="Hello!"
for i in str1:
print(i,end="")

#for循环作用于元组
tuple1=[("a",1),("b",2),("c",3)]
for (i,j) in tuple1: #不加括号也行
print(i,j)

#for循环作用于字典
person={"name":"catisher","career":"student"}
for key,value in person.items(): #items()的作用可以看做是将person中的键值对转为了一个个元组
print(key,value)

#for循环作用于集合
number={1,2,3,4,5}
for i in number: #由于集合实现的原因,遍历的顺序可能会和你给集合赋值时的顺序不一样
print(i)

#for循环作用于文件
'''
名为1.txt的文件中有以下内容:
漫游星空的旅者,
记录世界的法师。
'''
fd=open("./1.txt")
for line in fd:
print(line,end="")

函数

  1. 需要指出的是一个程序中若有多个同名函数且参数也一致,调用函数时最近的函数发挥作用
  2. python可以返回多个值,这与其元组数据类型密不可分
    1
    2
    3
    4
    def sortA(num1,num2)
    if num1>num2
    return num1,num2 #这里可以看做是元组
    else:return num2,num1
  3. 由于Python中一切都是对象,严格意义上说,调用函数时的参数传递不能说是值传递和引用传递,应该说是传可变对象和传不可变对象。
    • 对于不可变类型,例如func(a),a为一常数,传递的只是a的值,在func函数内部修改a的值,只是修改另一个复制的对象,不会影响a本身
    • 对于可变类型,例如func(a),a为列表,在func函数内部修改a的值,函数外部的a也会受到影响。

1
2
3
4
5
6
7
8
9
10
'''
格式:
class 类名:
类体
__init__()为类的初始化方法,每个类里的方法的第一个参数都必须为self。self指向的是调用方法的对象。
类的成员变量,在类中也被称作是属性,需要通过"self.变量名"的形式命名。
同其他语言一样的是,python中也可以定义由所有实例之间共享的一个变量。只需要在方法外命名。称作是类属性,与之相对的是对象属性。
属性可通过命名的方式设置访问权限:私有属性以__开头,共有属性则不用。
方法的权限设置同上
'''

sorted函数

sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
sorted(iterable, key=None, reverse=False)
iterable — 可迭代对象。
key — 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse — 排序规则,reverse = True 降序 , reverse = False 升序(默认)

enumerate函数

enumerate(sequence, [start=0])
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
Python 2.3. 以上版本可用,2.6 添加 start 参数。