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 <代码元素别名>

• 第一种场景：

m1模块

import m2
y = 20
print(m2.x)

m2模块

x = 20

• 第二种场景：

m1模块

from m2 import x
y = 20
print(x)

m2模块

x = 20

• 第三种场景

m1模块

from m2 import x as x2
x = 100
y = 20
print(x2)

m2模块

x = 20

数据类型

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的差
*	乘	a*b	求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 条件:
    语句

if 条件:
    语句
else:
    语句

if 条件1:
    语句
elif 条件2:
    语句
elif 条件3:
    语句
else:
    语句

循环语句

while 条件:
    语句
[else：
    语句
]

for 变量 in 可迭代对象:
    语句
[else：
    语句
]

容器

序列

序列是一种可迭代的、元素有序的容器类型的数据。

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

a = 'hello'
a[0]
len(a) # 获取序列长度
max(a) # 返回第一个元素
min(a) # 返回最后一个元素

序列的加和乘操作：

a = 'hello'
a *= 2 # a为hellohello
a = 'hello'
a += ',world' # a为hello,world

切片操作：

[start:end: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

成员测试：

in # 用于测试是否包含某一个元素
not in # 用于测试是否不包含某一个元素
a = 'hello'
'e' in a # True
'E' not in a # True

列表

列表（list）是一种可变序列类型，可以追加、插入、删除、替换列表中的元素。

创建列表

list('hello')
[1,2,3,4]
[]
['1',11,]

追加元素：

• 在列表中追加单个元素，可以使用列表的append()方法
• 在列表中追加多个元素，可以使用加（+）运算符或列表的extend()方法

list = [1,2,3]
list.append(4)
t = [5,6,7]
list.extend(t)
list += t

插入元素：

list = [1,2,3,]
list.insert(2,4) # [1,2,4,3]

替换元素：

list = [1,2,3]
list[0] = 4

删除元素：

list = [1,2,3]
list.remove(2)

元组

元组（tuple）是一种不可变序列类型。

创建元组：

tuple([1,2,3])
(1,2,3)

元组拆包：

s_id, s_name = (102,'bob')

集合

集合是一种可迭代的、无序的、不能包含重复元素的容器类型数据。

创建集合

set('hello')
{1,2,3}

修改集合：

st = {1,2,3}
st.add(4)
st.remove(1)
st.clear()

字典

字典是可迭代的、通过键来访问元素的可变的容器类型的数据。

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

创建字典：

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}

修改字典：

dt[k1] = v1
dt.pop(k1)

访问字典视图：

dt = {1:q,2:w,3:e}
dt.items() # 返回字典的所有键值对视图
dt.keys() # 返回字典键视图
dt.values() # 返回字典值视图

字符串

表示字符串

普通字符串：指用单引号或双引号括起来的字符串。

原始字符串：

r'hello\n world'

长字符串：

'''XXXXXX
XXXXXX
XXXXXX'''
或
"""XXXXXX
XXXXXX
XXXXXX"""

字符串与数字类型的转换

将字符串转换为数字：可以使用int()和float()实现，如果成功则返回数字，否则引发异常。

int('80')
float('80.0')
int('AB',16)

将数字转换为字符串：可以使用str()函数，可以将很多类型的数据都转换为字符串。

str(123)
str(True)

字符串格式化

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

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

# 默认占位符
'i*i={}'.format(i*i)
# 参数序号占位符
s='{0}*{0}={1}'.format(i,i*i)
# 参数名占位符
'{p1}*{p1}={p2}'.format(p1=i,p2=i*i)

格式化控制符：

{1:d}
{参数序号:格式化控制符}

格式化控制符	说明
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']

函数

定义函数

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

def 函数名(形式参数列表):
    函数体
    return 返回值

调用函数

使用位置参数调用函数

在调用函数时传递的实参与定义函数时的形参顺序一致，这是调用函数的基本形式。

使用关键字参数调用函数

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

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

r_area = rect_area(width=10,height=20)

参数的默认值

python中没有函数重载的概念，而是为函数的参数提供默认值实现的。

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

coffee1 = make_coffee()
coffee2 = make_coffee('b')

可变参数

基于元组的可变参数

*可变参数在函数中被组装成一个元组。

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

sum(1,2,3)

基于字典的可变参数

**可变参数在函数中被组装成一个字典。

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

show_info(name='a',age=18,sex=True)

函数变量的作用域

模块里定义：全局变量
函数里定义：局部变量

global x # 将x提升为全局变量

函数的类型

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)))

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]

映射函数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]

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)))

类与对象

定义类

class 类名[(父类)]:
类体

class Car(object):
    # 类体
    pass

创建对象

class Car(object):
    # 类体
    pass

car = Car()

类的成员

实例变量

实例变量就是对象个体特有的数据

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

d = Dog('bob',2)

_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))

类变量

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

类方法

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

interest = Account.interest_by(12.0)

私有变量

私有变量在变量前加上双下划线（__）

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

私有方法

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())	

使用属性

为了实现对象的封装，在一个类中不应该有共有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的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

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

继承

class Animal:
    def __init__(self,name):
        self.name = name

class cat(Animal):
    def __init__(self,name,age):
        super().__init__(name)
        self.age = age

多继承

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)

方法重写

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))

多态

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()

python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为（方法），它们之间就是多态的。

异常处理

异常捕获

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

try:
    result = n/0
except ZeroDivisionError as e:
    print(e)

多个except

try:
    res = n/0
except ZeroDivisionError as e:
    print(1)
except ValueError as e:
    print(2)
except:
    print(3)

多重异常捕获

try:
    res = n / 0
except (ZeroDivisionError,ValueError) as e:
    print(1)

使用finally代码块

try:
except:
finally:

自定义异常类

class MyException(Exception):
    def __init__(self,msg):
        super.__init__(msg)

手动引发异常

try:
    res = n / 0
except ZeroDivisionError as e:
    raise MyException('a')