Python基本语法

标识符
区分大小写；
首字符可以是下划线或字母，但不能是数字；
除首字符外的其他字符必须是下划线、字母和数字；
关键字不能作为标识符；
不要使用python的内置函数作为自己的标识符。
关键字
False、def、if、raise、None、del、import、return、True、elif、in、try、and、else、is、while、as、except、lambda、with、assert、finally、nonlocal、yield、break、for、not、class、from、or、continue、global、pass

变量
在python中为一个变量赋值的同时就声明了该变量，该变量的数据类型就是赋值数据所属的类型，该变量还可以接收其他类型的数据。

语句
在python中，一行代码表示一条语句，在一般情况下语句结束时不加分号。

模块
一个模块就是一个文件。
导入模块的三种方式：

import <模块名>
from <模块名> import <代码元素>
from <模块名> import <代码元素> as <代码元素别名>
1
2
3
第一种场景：
m1模块

import m2
y = 20
print(m2.x)
1
2
3
m2模块

x = 20
1
第二种场景：
m1模块

from m2 import x
y = 20
print(x)
1
2
3
m2模块

x = 20
1
第三种场景
m1模块

from m2 import x as x2
x = 100
y = 20
print(x2)
1
2
3
4
m2模块

x = 20
1
数据类型
python中有6种主要的内置数据类型：数字、字符串、列表、元组、集合、字典。
python中有4种数据类型：整数类型、浮点类型、复数类型、布尔类型。

整数类型：int
表示方式：
十进制：28
二进制：0b11100（以0B或0b作为前缀）
八进制：0O34（以0o或0O作为前缀）
十六进制：0x1c（以0x或0X作为前缀）
type()返回数据类型

浮点类型：float

复数类型：complex
1+2j表示实部为1，虚部为2的复数

布尔类型：bool
True、False
bool(0)为False
bool(2)为True
bool(1)为True
bool(‘’)为False
bool(’ ')为True
bool([])为False
bool({})为False

数字类型的相互转换
隐式类型的转换
显式类型的转换

运算符
算术运算符

运算符 名称 例子 说明

• 加 a+b 求a与b的和

• 减 a-b 求a与b的差

• 乘 ab 求a与b的积
  / 除 a/b 求a除以b的商
  % 取余 a % b 求a除以b的余数
  ** 幂 a**b 求a的b次幂
  // 地板除法 a//b 求小于a与b的商的最大整数
  比较运算符：==、!=、>、<、>=、<=
  逻辑运算符：not、and、or
  位运算符：~、&、|、^、>>、<<
  赋值运算符：+=、-=、=、/=、%=、**=、//=、&=、|=、^=、<<=、>>=

跳转语句
break、continue、return

流程控制
if 条件:
语句
1
2
if 条件:
语句
else:
语句
1
2
3
4
if 条件1:
语句
elif 条件2:
语句
elif 条件3:
语句
else:
语句
1
2
3
4
5
6
7
8
循环语句
while 条件:
语句
[else：
语句
]
1
2
3
4
5
for 变量 in 可迭代对象:
语句
[else：
语句
]
1
2
3
4
5
容器
序列
序列是一种可迭代的、元素有序的容器类型的数据。

正值索引：第一个元素的索引是0
负值索引：最后一个元素的索引是-1

a = ‘hello’
a[0]
len(a) # 获取序列长度
max(a) # 返回第一个元素
min(a) # 返回最后一个元素
1
2
3
4
5
序列的加和乘操作：

a = ‘hello’
a *= 2 # a为hellohello
a = ‘hello’
a += ‘,world’ # a为hello,world
1
2
3
4
切片操作：

[start🔚step]

start是开始索引

end是结束索引

step是步长（可以是正数或负数）

a = ‘hello’
a[0:3:2] # hl
a[:] # hello
a[:3] # hel等价于a[0:3]
a[1:-1] # ell
a[0:] # hello
1
2
3
4
5
6
7
8
9
10
11
成员测试：

in # 用于测试是否包含某一个元素
not in # 用于测试是否不包含某一个元素
a = ‘hello’
‘e’ in a # True
‘E’ not in a # True
1
2
3
4
5
列表
列表（list）是一种可变序列类型，可以追加、插入、删除、替换列表中的元素。

创建列表

list(‘hello’)
[1,2,3,4]
[]
[‘1’,11,]
1
2
3
4
追加元素：

在列表中追加单个元素，可以使用列表的append()方法
在列表中追加多个元素，可以使用加（+）运算符或列表的extend()方法
list = [1,2,3]
list.append(4)
t = [5,6,7]
list.extend(t)
list += t
1
2
3
4
5
插入元素：

list = [1,2,3,]
list.insert(2,4) # [1,2,4,3]
1
2
替换元素：

list = [1,2,3]
list[0] = 4
1
2
删除元素：

list = [1,2,3]
list.remove(2)
1
2
元组
元组（tuple）是一种不可变序列类型。

创建元组：

tuple([1,2,3])
(1,2,3)
1
2
元组拆包：

s_id, s_name = (102,‘bob’)
1
集合
集合是一种可迭代的、无序的、不能包含重复元素的容器类型数据。

创建集合

set(‘hello’)
{1,2,3}
1
2
修改集合：

st = {1,2,3}
st.add(4)
st.remove(1)
st.clear()
1
2
3
4
字典
字典是可迭代的、通过键来访问元素的可变的容器类型的数据。

键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。

创建字典：

dict({1:q,2:w,3:e})
dict(((1,q),(2,w),(3,e)))
dict([(1,q),(2,w),(3,e)])
dict(zip([1,2,3],[q,w,e]))
dt = {}
dt = {1:q,2:w,3:e}
1
2
3
4
5
6
修改字典：

dt[k1] = v1
dt.pop(k1)
1
2
访问字典视图：

dt = {1:q,2:w,3:e}
dt.items() # 返回字典的所有键值对视图
dt.keys() # 返回字典键视图
dt.values() # 返回字典值视图
1
2
3
4
字符串
表示字符串
普通字符串：指用单引号或双引号括起来的字符串。

原始字符串：

r’hello\n world’
1
长字符串：

‘’‘XXXXXX
XXXXXX
XXXXXX’‘’
或
“”“XXXXXX
XXXXXX
XXXXXX”“”
1
2
3
4
5
6
7
字符串与数字类型的转换
将字符串转换为数字：可以使用int()和float()实现，如果成功则返回数字，否则引发异常。

int(‘80’)
float(‘80.0’)
int(‘AB’,16)
1
2
3
将数字转换为字符串：可以使用str()函数，可以将很多类型的数据都转换为字符串。

str(123)
str(True)
1
2
字符串格式化
使用字符串的format()方法，它不仅可以实现字符串的拼接，还可以格式化字符串。

占位符：要想将表达式的计算结果插入字符串中，则需要用到占位符{}。

默认占位符

'ii={}'.format(ii)

参数序号占位符

s='{0}{0}={1}'.format(i,ii)

参数名占位符

'{p1}{p1}={p2}'.format(p1=i,p2=ii)
1
2
3
4
5
6
格式化控制符：

{1:d}
{参数序号:格式化控制符}
1
2
格式化控制符 说明
s 字符串
d 十进制整数
f、F 十进制浮点数
g、G 十进制整数或浮点数
e、E 科学计数法表示浮点数
o 八进制整数，符号是小英文字母o
x、X 十六进制整数，x是小写表示，X是大写表示
操作字符串
字符串查找
str.find(sub[,start[,end]])查找子字符串，在索引start到end之间查找子字符串sub，如果找到，则返回最左端位置的索引；如果没有找到，则返回-1。

字符串替换
str.replace(old,new[,count])字符串替换，new子字符串替换old子字符串。count参数指定了替换old子字符串的个数，count被省略，则替换所有old子字符串。

字符串分割
str.split(sep=None,maxsplit=-1)，使用sep子字符串分割字符串str。maxsplit是最大分割次数，如果maxsplit被省略，则表示不限制分割次数。

text=‘AB CD EF GH IJ’
text.split(’ ',maxsplit=2)

[‘AB’,‘CD’,‘EF GH IJ’]

1
2
3
函数
定义函数
python中的函数很灵活：可以在模块中但是类之外定义，作用域是当前模块，称为函数；也可以在别的函数中定义，称为嵌套函数；还可以在类中定义，称为方法。

def 函数名(形式参数列表):
函数体
return 返回值
1
2
3
调用函数
使用位置参数调用函数
在调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式。

使用关键字参数调用函数
在调用函数时可以采用“关键字=实参”的形式，其中，关键字的名称就是定义函数时形参的名称。

def rect_area(width,height):
area = width * height
return area

r_area = rect_area(width=10,height=20)
1
2
3
4
5
参数的默认值
python中没有函数重载的概念，而是为函数的参数提供默认值实现的。

def make_coffee(name=‘a’):
return ‘make {0}’.format(name)

coffee1 = make_coffee()
coffee2 = make_coffee(‘b’)
1
2
3
4
5
可变参数
基于元组的可变参数
*可变参数在函数中被组装成一个元组。

def sum(*numbers):
total = 0.0
for num in numbers:
total += num
return total

sum(1,2,3)
1
2
3
4
5
6
7
基于字典的可变参数
**可变参数在函数中被组装成一个字典。

def show_info(**info):
for k,v in info.items():
print(‘{0} {1}’.format(k,v))

show_info(name=‘a’,age=18,sex=True)
1
2
3
4
5
函数变量的作用域
模块里定义：全局变量
函数里定义：局部变量

global x # 将x提升为全局变量
1
函数的类型
python中任意一个函数都有数据类型，这种数据类型是function，被称为函数类型。

一个函数可以作为另一个函数返回值使用。
一个函数可以作为另一个函数参数使用。

def sub(a,b):
return a-b

def sum(a,b):
return a+b

def calc(apr):
if opr == ‘+’:
return sum
else:
return sub

f1 = calc(‘+’)
f2 = calc(‘-’)
print(‘{0}’.format(f1(1,2)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
lambda函数
过滤函数filter
filter(function,iterable)

def f1(x):
return x>50
data1 = [66,15,91,28,98,50,7,80,99]
filtered = filter(f1,data1)
data2 = list(filtered)
print(data2) # [66,91,98,80,99]
1
2
3
4
5
6
映射函数map
map(function,iterable)

def f1(x):
return x*2

data1 = [1,2,3]
mapped = map(f1,data1)
data2 = list(mapped)
print(data2) # [2,4,6]
1
2
3
4
5
6
7
lambda函数
在python中使用lambda关键字定义匿名函数。

def calc(opr):
if opr == ‘+’:
return lambda a,b: (a+b)
else:
return lambda a,b: (a-b)

f1 = calc(‘+’)
print(‘{0}’.format(f1(10,2)))
1
2
3
4
5
6
7
8
类与对象
定义类
class 类名[(父类)]:
类体

class Car(object):
# 类体
pass
1
2
3
创建对象
class Car(object):
# 类体
pass

car = Car()
1
2
3
4
5
类的成员
实例变量
实例变量就是对象个体特有的数据

class Dog:
def init(self,name,age):
self.name = name
self.age = age

d = Dog(‘bob’,2)
1
2
3
4
5
6
init()方法是构造方法，构造方法用来初始化实例变量。

实例方法
class Dog:
def init(self,name,age):
self.name = name
self.age = age

def run(self):
    print('{}'.format(self.name))

def speak(self,sound):
    print('{}'.format(sound))
1
2
3
4
5

1
2
3
4
5
6
7
8
9
10
类变量
class Account:
rate = 1.0
def init(self,a,b):
self.a = a
self.b = b

account = Account(1,2)
account.a
account.b
Account.rate
1
2
3
4
5
6
7
8
9
10
类方法
class Account:
rate = 1.0
def init(self,a,b):
self.a = a
self.b = b

@classmethod # 装饰器
def interest_by(cls,amt):
    return cls.rate * amt
1
2
3

interest = Account.interest_by(12.0)
1
2
3
4
5
6
7
8
9
10
11
私有变量
私有变量在变量前加上双下划线（__）

class Account:
rate = 1.0
def init(self,a,b):
self.a = a
self.__b = b

def desc(self):
    return self.a*self.__b*Account.rate
1
2

1
2
3
4
5
6
7
8
私有方法
class Account:
def init(self,a,b):
self.a = a
self.b = b

def __get_info(self):
    return a * b

def desc(self):
     print(self.__get_info())	
1
2
3
4
5

1
2
3
4
5
6
7
8
9
10
使用属性
为了实现对象的封装，在一个类中不应该有共有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set和get方法访问。

class Dog:
def init(self,name,age):
self.name = name
self.__age = age

def run(self):
    print(self.name)

@property
def age(self):
    return self.__age

@age.setter
def age(self,age):
    self.__age = age
1
2
3
4
5
6
7
8
9
10

dog = Dog(1,2)
dog.age = 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
继承
class Animal:
def init(self,name):
self.name = name

class cat(Animal):
def init(self,name,age):
super().init(name)
self.age = age
1
2
3
4
5
6
7
8
多继承
class Horse:
def init(self,name):
self.name = name

class Donkey:
def init(self,name):
self.name = name

class Mule(Horse,Donkey):
def init(self,name):
super().init(name)
1
2
3
4
5
6
7
8
9
10
11
方法重写
class Horse:
def fun(self,a):
return ‘Horse{}’.format(a)

class Donkey:
def fun(self,a):
return ‘Donkey{}’.format(a)

class Mule(Horse,Donkey):
def fun(self,a):
return ‘Mule{}’.format(a)

m = Mule()
print(m.fun(1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
多态
class Animal:
def speak(self):
print(‘1’)

class Dog(Animal):
def speak(self):
print(‘2’)

class Cat(Animal):
def speak(self):
print(‘3’)

an1 = Dog()
an2 = Cat()
an1.speak()
an2.speak()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为（方法），它们之间就是多态的。

异常处理
异常捕获
try:
<可能会引发异常的语句>
except [异常类型]:
<处理异常>

try:
result = n/0
except ZeroDivisionError as e:
print(e)
1
2
3
4
多个except
try:
res = n/0
except ZeroDivisionError as e:
print(1)
except ValueError as e:
print(2)
except:
print(3)
1
2
3
4
5
6
7
8
多重异常捕获
try:
res = n / 0
except (ZeroDivisionError,ValueError) as e:
print(1)
1
2
3
4
使用finally代码块
try:
except:
finally:
1
2
3
自定义异常类
class MyException(Exception):
def init(self,msg):
super.init(msg)
1
2
3
手动引发异常
try:
res = n / 0
except ZeroDivisionError as e:
raise MyException(‘a’)