Python3基础语法(v3.7)

[TOC]

数据类型

整数、浮点

  • 除法计算/(除法)、//(取整除法)、%(取余)、**(幂运算)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> 10/3
3.3333333333333335
>>> 9/3
3.0
>>> 10//3
3
>>> 9//3
3
>>> 10%3
1
>>> 9%3
0
>>> 3**2
9

Python3中提供两种除法/计算结果是浮点值//叫做取整除法,计算结果是整数,即使除不尽。

字符串

用单引号'或双引号"括起来的任意文本。如:abcdefg"abcdefg"

Python3采取Unicode编码,因此Python3支持多语言。

表示法

  • 转义字符 \,如:(\n、\t、\)等等
1
2
3
4
5
>>> print('C:\new')
C:
ew
>>> print('C:\\new')
C:\new
  • r' ' 或 r" "

内部字符串默认不转义

1
2
>>> print(r'C:\new')
C:\new

Python通过引入re模块match()方法进行正则匹配。正则表达式可以直接以' '" "形式表示,因为Python字符串本身也用\符号转义,如果使用r正则表示法,就不再需要考虑\转义符。

1
2
3
4
5
6
s = '(?<=@)\\S+(?=\\s)' 
|_______________
| 两种方法意思相同|
| ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄ ̄
V
s = r'(?<=@)\S+(?=\s)'

r''表示法最后不能有\,可以使用r''+'\\'方法代替。

1
2
3
4
>>> r'C:\new\'
SyntaxError: EOL while scanning string literal
>>> r'C:\new'+'\\'
'C:\\new\\'

更多正则语法参考正则表达式语法

  • '''...'''"""...""" 自定义格式字符串
1
2
3
4
5
6
>>> print('''abc
... def
... cc''')
abc
def
cc
  • b' 'b" " 字节表示法
    Python3对bytes类型用b作为前缀来表示。

以Unicode表示的字符串可以通过encode() / decode() 函数编(解)码为字节或字符串

1
2
3
4
>>> '中'.encode('utf-8')
b'\xe4\xb8\xad'
>>> b'\xe4\xb8\xad'.decode('utf-8')
'中'

格式化

Python3中有两种格式化方法:一种是%,另一种是利用format()函数。
通常作用%方法比较简洁,具体用法如下:

1
2
3
4
>>> 'Hello, %s' % 'Python3'
'Hello, Python3'
>>> '%s got %d on the math test' % ('Lili',100)
'Lili got 100 on the math test'

format格式化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> st = 'a,{0},c,{1}'.format('b','d') #位置格式化
>>> st
'a,b,c,d'

>>> sk = 'a,{b},c,{d}'.format(b='b', d='d') #关键字格式化
>>> sk
'a,b,c,d'

>>> sm = 'a,{b},c,{0}'.format('d', b='b') #混合使用格式化(位置参数在前,关键字参数在后)
>>> sm
'a,b,c,d'

>>> sm = 'a,{b},c,{0}'.format(b='b', 'd') #报错原因关键字参数在位置参数之后
SyntaxError: positional argument follows keyword argument

>>> sp2 = '{0} = {1:.3f}'.format('𝞹',3.1415926)
>>> sp2
𝞹 = 3.142 #:表示格式化符号.3f表示保留3位浮点数,且自动四舍五入

格式化符号:

符号   说明
%c 格式化字符及其ASCII码
%d 整型
%f 浮点型
%s 字符型
%x 十六进制
%e 科学计数法
1
2
3
4
5
#两种表示法意思相同
>>> '{0:c},{1:c}'.format(97,98)-->
'a,b'
>>> %c,%c' % (97,98)-->'a,b'
'a,b'

格式化辅助符号:

符号   说明
m.n m表示显示最小总宽度n表示小数点后位数
- 左对齐
+ 正数前面显示+号
# 八进制前面显示(0),十六进制前面显示(0x 或 0X)
0 数字前面填充0

布尔值

布尔值有两种值TrueFalse,实际上布尔值是特殊的整数True=1,False=0

  • 条件运算andornot
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# and
>>> True and True
True
>>> True and False
False
>>> False and False
False

# or
>>> True or True
True
>>> True or False
True
>>> False or False
False

# not
>>> not True
False
>>> not False
True

空值

python里用None表示空值

列表(list)

Python3内置数据类型,是一种可变的有序的集合。

  • 声明
1
2
3
4
5
>>> colors=['red','black','white']
>>> colors
['red', 'black', 'white']
>>> len(colors)
3
  • 读取

可以通过索引获取元素,索引从0开始

1
2
3
4
5
6
>>> colors[0]
'red'
>>> colors[-1] # 可以通过负数从后往前读取
'white'
>>> colors[-2]
'black'
  • append() 追加元素
1
2
3
>>> colors.append('green')
>>> colors
['red', 'black', 'white', 'green']
  • extend() 追加列表
    append的函数一次只能追加一个元素,如果想要同时追加多个元素使用extend()方法,该方法接收一个iterable(迭代对象)参数。
1
2
3
>>> colors.extend(['pink','yellow'])
>>> colors
['red', 'black', 'white', 'green', 'pink', 'yellow']

append()函数也可以接收一个如上面list参数,但与extend()区别是此函数会把此list当作一个元素追加到列表。

1
2
3
>>> colors.append(['blue','purple'])
>>> colors
['red', 'black', 'white', 'green', 'pink', 'yellow', ['blue', 'purple']]
  • insert() 指定位置插入元素
1
2
3
>>> colors.insert(1,'purple')
>>> colors
['red', 'purple', 'black', 'white', 'green', 'pink', 'yellow', ['blue', 'purple']]
  • pop(index=-1) 删除元素

默认删除索引为-1的元素(也就是最后一个元素)。

1
2
3
4
5
6
7
8
>>> colors.pop()
['blue', 'purple']
>>> colors
['red', 'purple', 'black', 'white', 'green', 'pink', 'yellow']
>>> colors.pop(2) #删除指定位置元素
'black'
>>> colors
['red', 'purple', 'white', 'green', 'pink', 'yellow']
  • remove() 删除指定元素
1
2
>>> colors.remove('white')
['red', 'purple', 'green', 'pink', 'yellow']

list可以存储不同数据类型,也可以存储list,因此读取元素类型为list的元素时可以看成是多维数组的读取。如:colors[0][1]

元组(tuple)

tuple是一组有序不可变的元组,一旦初始化后,不能被改变。

  • 声明
1
>>> colors=('red','black','white')
  • 读取

与list一样采用索引方式读取,索引从0开始。但没有append()、pop()等方法,因为不可变。

理论上tuple是不可变的,但可以通过两个tuple相加获取第三个tuple实现改变。如果tuple中的元素是list类型,则list元素里的内容也是可变的。

1
2
3
4
5
6
7
8
9
10
11
12
# tuple相加
>>> tup1 = (12, 34.56)
>>> tup2 = ('abc', 'xyz')
>>> tup3 = tup1 + tup2
>>> tup3
(12, 34.56, 'abc', 'xyz')

# 改变tuple中list元素
>>> tup = ('red',['black','green'])
>>> tup[1][0]='pink'
>>> tup
('red', ['pink', 'green'])
  • 空元组
1
2
3
>>> colors=()
>>> colors
()

当定义只有一个元素的tuple时,由于()既可以表示tuple又可以表示数学符号,因此会产生歧义。Python规定,这种情况按数学符号小括号进行计算,计算结果为1。所以声明只有一个元素的tuple时必须加一个,来消除歧义。

1
>>> colors=('red',) #声明一个元素的tuple

tuple也可以使用切片进行复制和读取。

字典(dict)

字典采用键值对形式存储,也称为Map,查找速度快。

  • 声明
1
>>> scores={'Math':95,'Chi':98,'Eng':92}
  • 读取
1
2
3
4
>>> scores['Math'] #通过键名读取,如果key不存在会报错
95
>>> scores.get('Chi') #通过get()方法读取,如果key不存在,会返回None,交互环境下不显示结果
98

- 键值判断 in

为了以免key不存在而报错,除了上面的get()方法外,还可以通过in来判断。

1
2
>>> 'Eng' in scores
True
  • 删除
1
2
3
4
>>> scores.pop('Math')
95
>>> scores
{'Chi': 98, 'Eng': 92}

字典查找速度快,且不会随着key的增加而变慢。但需要占用大量内存,是用空间换时间的一种方法。而集合恰好相反,占用空间小,但会随着元素增加而变慢。

集合(set)

是一组无序的不存在重复元素的集合。

  • 声明
1
2
3
>>> names=set(['Micheal','Jack','Bob'])
>>> names
{'Bob', 'Jack', 'Micheal'} #存储时使用[]但读取时显示的是{}
  • 读取

  • 存储
    集合通过add()方法添加元素,当添加的元素已存在时,不会报错,但是不会显示。

1
2
3
4
>>> names.add('James')
>>> names.add('Bob') #重复添加Bob
>>> names
{'Bob', 'Jack', 'Micheal', 'James'} #依然显示一个Bob
  • 删除
1
2
3
>>> names.remove('Bob')
>>> names
{'Jack', 'Micheal', 'James'}

变量

由于Python的动态语言特性,变量不需要声明也不需要指定类型。

1
2
3
4
5
6
7
8
9
>>> test=1
>>> print(test)
1
>>> test='abc'
>>> print(test)
abc
>>> test=True
>>> print(test)
True

常量

Python没有严格意义上的常量,定义的常量仍然可以修改。习惯上用大写字母表示常量:

1
2
3
4
5
6
>>> VERSION='v1.0'
>>> print(VERSION)
v1.0
>>> VERSION='V2.0'
>>> print(VERSION)
v2.0

条件判断

if

1
2
if True :
print('true')

else

1
2
3
4
if True :
print('true')
else :
print('false')

elif

1
2
3
4
5
6
7
8
temp=input('请输入一个数字:')
guess=int(temp) #input输入的为字符串需要先通过内置函数int()转换成整数
if guess > 10 :
print('大于10的数字')
elif guess > 20 :
print('大于20的数字')
else :
print('其它数字')

三元操作符

Python从2.5版本后开始支持三元操作符,来简化if…else操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
x = input()
y = input()

if x > y:
temp = x
else:
temp = y
|优|
|化|
|代|
|码|
V V
temp = x if x > y else y

变量判断

1
2
if x :
print('True')

只要x是非零数值、非空字符串、非空list等,就判断为True,否则为False

循环

for…in

for…in循环可以迭代出list、tuple、dict、set、str、range()等。

1
2
3
4
5
6
7
#通过内置函数打印0到9的数字
for num in range(10) :
print(num)

#打印list中的名字
for name in ['Micheal','Jack'] :
print(name)

for循环,可作用于一切可迭代对象,无论该对象有无下标。当迭代字典时默认迭代的是key,如果想要迭代values可使用values()内置函数for value in d.values(),如果两者想要同时迭代可使用items()内置函数for k,v in d.items()

既然for循环可以作用于一切可迭代对象,那么如何判断一个对象是否为可迭代对象呢?可以通过collections模块Iterable进行判断,如下:

1
2
3
>>> from collections import Iterable
>>> isinstance(d,Iterable) #判断字典d是否可迭代对象
True

for循环实现下标循环(enumerate):

1
2
3
4
5
6
7
8
d={'name':'张三','sex':'男','age':'18'}
for i,value in enumerate(d) : #通过enumerate函数实现下标循环
print(i,value)

结果:
0 name
1 sex
2 age

while

当while满足指定条件就会不断循环。

1
2
3
4
n=0
while n < 10 :
n += 1 #Python不支持++运算符
print(n)

break

在循环中可以通过break跳出循环。

1
2
3
4
5
6
n=0
while n < 10 :
n += 1 #Python不支持++运算符
print(n)
if n == 5 :
break

continue

在循环中通过continue跳过本次循环。

1
2
3
4
5
6
n=0
while n < 10 :
if n == 5 :
continue
n += 1 #Python不支持++运算符
print(n)

with语句

任何对象,只要正确实现了上下文管理,就可以用于with语句。
实现上下文管理是通过__enter____exit__这两个方法实现的。典型的使用场景IO编程open()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class UseWith(object):
def __init__(self):
pass
def __enter__(self):
pass
def __exit__(self):
pass

def func(self):
pass

#使用with语句
with UserWith() as uw:
uw.func()

实现上下文方法比较繁琐,Python提供contextlib标准库提供了更简便的写法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from contextlib import contextmanager

class UseWith(object):
def __init__(self):
pass
def func(self):
pass

@contextmanager
def create_func():
q = UseWith()
yield q


with create_func() as cf:
cf.func()

@contextmanager这个decorator接受一个generator,用yield语句把with ... as var把变量输出出去,然后,with语句

切片

切片的作用是对于列表、元组以及字符串截取的高阶操作,实现快速截取元素。其表示形式为:[开始索引:结束索引(不包括此索引):间隔索引]

以上面列表colors为例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> colors
['red', 'black', 'white', 'pink', 'yellow']
>>> colors[1:4] #截取索引为1到索引4的元素(不包括4)
['black', 'white', 'pink']

>>> colors[1:] #冒号后无值表示从指定索引开始截取到最后
['black', 'white', 'pink', 'yellow']

>>> colors[:2] #同理,冒号前无值表示从索引0开始截取到指定索引
['red', 'black']

>>> colors[-2:] #同列表索引读取一样切片也支持负数
['pink', 'yellow']

>>> colors[:] #空切片表示完整复制一个列表
['red', 'black', 'white', 'pink', 'yellow']

>>> colors[:5:2] #两个冒号表示每隔多少切片一次
['red', 'white', 'yellow']

列表生成式

列表生成式是Python内置的可用来生成list的生成式。

  • 生成最简单的集合
1
>>> list(range(1,11))
  • 生成特殊值的集合(如偶数集合)

方法一: for循环

1
2
3
4
5
6
7
L = []
for n in range(1,11) :
if n % 2 == 0 :
L.append(n)
print(L)

结果:[2, 4, 6, 8, 10]

方法二: 列表生成式

1
2
3
4
L = [x for x in range(1,11) if x % 2 == 0]
print(L)

结果:[2, 4, 6, 8, 10]

通过上面代码结果显而易见,列表表达式更加简洁。同时列表表达式还支持多个变量,嵌套循环等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#嵌套循环
>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

#多变量(以前面字典scores为例)
>>> [k + '=' + str(v) for k,v in scores.items()]
#因为字典值为int不能与字符串相加所以用str()函数转换为字符串

['Math=95', 'Chi=98', 'Eng=92']

# 把list中字母转小写
>>> L = [chr(x) for x in range(ord('A'),ord('Z'))]
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y']

>>> [x.lower() for x in L]
['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y']