基本语法

注释：

单行：
# 单行
多行：
'''
第一行
第二行
'''

"""
第一行
第二行
"""

六种数据类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

type()或者isinstance()判断数据类型

del var_1,var_2 删除单个或多个对象

1. number（数字）
   包括int,float,bool,complex（复数）四种

数值运算：

>>>5 + 4  # 加法

9

>>> 4.3 - 2 # 减法

2.3

>>> 3 * 7  # 乘法

21

>>> 2 / 4  # 除法，得到一个浮点数

0.5

>>> 2 // 4 # 除法，得到一个整数（整除）

0

>>> 17 % 3 # 取余 

2

>>> 2 ** 5 # 乘方

32

2. string（字符串）
   用'或者"括起来，\转义特殊字符

+号：字符串连接符

*号：赋值当前字符串，紧跟的数字代表赋值次数

字符串索引：

索引：变量[下标] 从前往后：0_{n，从后往前-1}-n

截取：变量[头下标:尾下标]

str = 'Runoob'

print (str)          # 输出字符串

print (str[0:-1])    # 输出第一个到倒数第二个的所有字符

print (str[0])       # 输出字符串第一个字符

print (str[2:5])     # 输出从第三个开始到第五个的字符

print (str[2:])      # 输出从第三个开始的后的所有字符

print (str * 2)      # 输出字符串两次

print (str + "TEST") # 连接字符串

print (r'Ru\noob')   # 加上r表示原样输出不转义

反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

字符串中的元素不可变，比如不能这样赋值：str[1] = 'a'

3. list（列表）

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（嵌套）

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]

可以和字符串一样截取、索引和拼接，不同的是列表内的元素是可变的，可以进行赋值操作：list[1]='b'

删除一个元素：del list[2]

4. tuple（元组）
   和列表类似，不同之处在于元素不可变，不能修改

tuple=('abcd', 786 , 2.23, 'runoob', 70.2 )

虽然元组不可修改，但可以包含可变的元素，比如列表。

特殊规则：

tup1 = ()    # 空元组

tup2 = (20,) # 一个元素，需要在元素后添加逗号

5. set（集合）
   一个无序不重复元素的序列，

student = {'Tom', 'Jim', 'Mary'}

a = set('abcde')

b = set('bcdf')

print(a - b)     # a和b的差集 

print(a | b)     # a和b的并集

print(a & b)     # a和b的交集

print(a ^ b)     # a和b中不同时存在的元素

6. dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

在同一个字典中，键(key)必须是唯一的。

定义：

dict = {}

dict['one'] = "1 - 菜鸟教程"

dict[2]     = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

取值：

print (dict['one'])       # 输出键为 'one' 的值

print (dict[2])           # 输出键为 2 的值

print (tinydict)          # 输出完整的字典

print (tinydict.keys())   # 输出所有键

print (tinydict.values()) # 输出所有值

• 类型转换

运算符
算数运算符：+、-、、/、%、*、//

比较运算符：==、!=、>、<、>=、<=

赋值运算符：=、+=、-=、=、.=、/=、%=、*=、//=

位运算符：&、|、^、~、<<、>>

逻辑运算符：and、or、not

成员运算符：in、not in

身份运算符：is、is not

if语句（没有switch）

if condition_1:

    statement_block_1

elif condition_2:

    statement_block_2

else:

    statement_block_3

while语句（没有do...while）

while condition:

    statement_block

while condition:

    statement_block1

else:

    statement_block2

for循环

for <variable> in <sequence>:

    <statements>

else:

    <statements>

break跳出循环

continue跳过当前循环剩余语句，继续下一轮循环

pass空语句

迭代器和生成器iter,yield

自定义函数

def 函数名（参数列表）:

    函数体

• python 函数的参数传递：

1. 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

2. 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

3. 必需参数:

入参方式：test(123) 严格按照顺序匹配，不填会报错

4. 关键字参数:

入参方式：test(name="123",sex="boy") 顺序可变，会自动识别

5. 默认参数:

定义方式def test(name="123")

入参方式：test()

6. 不定长参数

定义方式：

def test(a,*b,c) b以元组形式传入

def test(a,**b,c) b以字典形式传入

注：不定长参数后面的c参数一定要用关键字参数传入（c=X）。

匿名函数：

lambda [arg1 [,arg2,.....argn]]:expression

例：

# 可写函数说明

sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数

print ("相加后的值为 : ", sum( 10, 20 ))

return语句：退出函数并返回一个表达式。不带参数的return返回None

变量作用域

L （Local） 局部作用域

E （Enclosing） 闭包函数外的函数中

G （Global） 全局作用域

B （Built-in） 内建作用域

以 L –> E –> G –>B 的规则查找

只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

当内部作用域想修改外部作用域的变量时，用global和nonlocal（嵌套作用域时使用）关键字

模块

可以理解为一个.py结尾的文件，里面定义了一些参数或方法供外部引用。

import module1,module2,...  引入整个文件

from module import func1,func2   引入部分方法

from module import *  引入全部

name属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用name属性来使该程序块仅在该模块自身运行时执行。

内置函数dir()找到模块内定义的所有名称

包

一种管理 Python 模块命名空间的形式

目录只有包含一个叫做 init.py 的文件才会被认作是一个包

import sound.effects.echo

from sound.effects import echo

从一个包中导入*

在init.py中配置参数：

__all__ = ['echo','reverse'];

输出

str()

print()

write()

format() zfill() ljust() rjust() center()等方法格式化输出

输入

input() 从键盘读入

open() 从文件读入

错误处理

try:

    f = open('myfile.txt')

    s = f.readline()

    i = int(s.strip())

except OSError as err:  //处理对应错误

    print("OS error: {0}".format(err))

except (TypeError,ValueError):  //可以同时处理多个

    print("Could not convert data to an integer.")

except:   //default错误

    print("Unexpected error:", sys.exc_info()[0])

    raise

else:  //放在最后面，没有发生任何错误时执行

    print("NO Error")

finally:  //无论如何都会执行的清理程序

    print("goodbye")

抛出一个异常

raise NameError('msg')

面向对象

定义类：

class Name:

    ....

类对象

变量/方法

init方法:实例化时自动调用

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self（可以自定义），代表类的实例。

class Test:

    def prt(self):

        print(self)

        print(self.__class__)

 

t = Test()

t.prt()

继承：

class DerivedClassName(BaseClassName1):

    ....

    

class DerivedClassName(moduleName.BaseClassName1):



class DerivedClassName(BaseClassName1,BaseClassName2):

若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法

子类可以重写父类的方法，super()方法用来调用父类的方法。

私有属性/私有方法:用__开头，只能在类内部调用

__privateattrs

def __privatemethod