Python3基础语法(v3.7)

风尘

文章目录

  1. 1. 数据类型
    1. 1.1. 整数、浮点
    2. 1.2. 字符串
      1. 1.2.1. 表示法
      2. 1.2.2. 格式化
    3. 1.3. 布尔值
    4. 1.4. 空值
    5. 1.5. 列表(list)
    6. 1.6. 元组(tuple)
    7. 1.7. 字典(dict)
    8. 1.8. 集合(set)
    9. 1.9. 变量
    10. 1.10. 常量
  2. 2. 条件判断
    1. 2.1. if
    2. 2.2. else
    3. 2.3. elif
    4. 2.4. 三元操作符
    5. 2.5. 变量判断
  3. 3. 循环
    1. 3.1. for…in
    2. 3.2. while
    3. 3.3. break
    4. 3.4. continue
  4. 4. with语句
  5. 5. 切片
  6. 6. 列表生成式

[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

求模运算和求余运算在第一步不同: 取余运算在取值时,向0 方向舍入(fix()函数);而取模运算在计算值时,向负无穷方向舍入(floor()函数)。当两变量符号一致时,求模运算和求余运算所得的值是一致的。

1
2
>>> -7%4
1 # python中为取模运算结果为1而不是3;在c/c++,java中用取余运算结果为-3。

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'

格式化辅助符号:

符号 说明
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']