基础知识汇总
标识符
-
第一个字符必须是字母表中字母或下划线 _ 。
-
标识符的其他的部分由字母、数字和下划线组成。
-
标识符对大小写敏感。
python保留字
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
注释
Python中单行注释以 # 开头，实例如下：
# 第一个注释
多行注释可以用多个 # 号，还有 ''' 和 """：
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
行与缩进
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
if True:
print ("True")
else:
print ("False")
多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：
total = item_one +
item_two +
item_three
在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
-
int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
-
bool (布尔), 如 True、False。
-
float (浮点数), 如 1.23、3E-2
-
complex (复数), 如 1 + 2j、 1.1 + 2.2j
字符串(String)
-
python中单引号和双引号使用完全相同。
-
使用三引号('''或""")可以指定一个多行字符串。
-
转义符 ''
-
反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with " 则 会显示，并不是换行。
-
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
-
字符串可以用 + 运算符连接在一起，用 * 运算符重复。
-
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
-
Python中的字符串不能改变。
-
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
-
字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
str='Runoob'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print('hello
runoob') # 使用反斜杠()+n转义特殊字符
print(r'hello
runoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
----------------------结果---------------------
Runoob
Runoo
hello
runoob
hellonrunoob
由独立字符组成的一个序列
单引号双引号三引号中的字符串是完全相同的
方便内嵌带引号的字符串
三引号多用于行字符串
支持转义字符，用带的字符串来表示一些特定意义的字符串
ewline 接下一行
' 表示单引号
" 表示双引号
换行
横向制表符
退格
v 纵向制表符
支持索引、切片、遍历
index=0表示第一个字符
[index:index+2]表示第一个index到index+1个元素组成的字符串
python的字符串是不可变的
遍历操作
for char in name:
print(char)
j
a
s
o
n
如何改变字符串？
第一种方法
s = 'H' + s[1:]
s = s.replace('h', 'H')
'+='字符串拼接法
str1 +=str2 #表示str1 = str1 +str2
字符串的分割函数：
split()
string.split(separator)
表示字符串按照separator分割成子字符串
string.strip(s)表示去掉首尾的s
string.lstrip(s)只去掉开头的s
string.rstrip(s)之去掉结尾的s
string.find(sub,start,end)
从start到end查找sub的位置
string.format()就是所谓的格式化函数
同一行显示多条语句
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割
序列类型
列表（list）
元组(tuple)
他们都是一个可以放置任意数据类型的有序集合（可以混参不同数值类型！）列表是动态的，长度大小不固定，可以随便的增加删减或者改变元素！元组是静态的，长度大小固定，支持切片，可随意嵌套
可以通过list()、tuple()互相转换
count() 统计列表中元素出现的次数
index() 返回列表中某元素第一次出现的位置的索引
reverse() list.reverse和list.sort原地的倒转序列和排序，元组没有内置的这两个函数
l.sort()
list(reversed(tup)) reversed()和sorted()功能相似但会返回一个更新后的新列表
sorted(tup)
由于列表是动态的，所以要存储指针，来指向对应元素，且需要额外存储已经分配好的长度大小（8字节），元组比列表轻量级，且性能速度略优
资源缓存
初始化操作，元素比列表块5倍，索引操作相差几乎可以忽略不记
字典(dict)
集合(Set)
字典和集合：
字典是一系列由键和值配对组合而成的元素的集合。3.6之前是无序的
长度大小可变且元素可以增删改查
相较于列表和元组字典性能更优，特别在查找增加和删除上
集合和字典基本相同，唯一区别是没有键值匹配
是一系列无序的唯一的元素组合
字典访问可以直接索引键，如果不存在，则会抛出异常
可以使用get(key,default)来进行索引，如果键不存在，get返回'null'
集合不支持索引操作，集合本质是一个哈希表，和列表不一样
value in dict/set
支持增删改查
d.pop()删除键值对
集合中的pop()是删除集合的最后一个元素，集合是无序的该操作要慎用
内部结构均是一张哈希表
哈希冲突
内部的哈希表的存储结构保证了增删改查的高效性
-
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
-
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
1.常用运算符：
+ - * / %（取余） //（取整数） **（次方）
字符串转义
字符前面加上 ，字符就不再表示字符本身的意思，表示ASCII码中 不能显示字符，常见有下：
n 换行
t 水平制表符
b 退格
r 回车，当前位置移到本行开头
\ 代表反斜杠
’ 代表一个单引号，同样的 “ 等符号也可以这么输出
0 代表一个空字符
a 系统提示音
在python中如果要去掉字符串的转义，只需要在字符串前面加上 r
在python中如果要去掉字符串的转义，只需要在字符串前面加上 r
r'abc abc'
字符串拼接
1.使用 +
str1 + str2 + str3
2.格式化字符串
' %s %s %s ' %(str1,str2,str3)
3.使用join
’字符’.join([str1, str2, str3])
4.使用 format格式化输出
' {} {} {} '.format(obj1,obj2,obj3)' {0} {1} {2} '.format(obj1,obj2,obj3)' {1} {0} {2} '.format(obj1,obj2,obj3)' {n0} {n1} {n2} '.format(n1=obj1,n0=obj2,n2=obj3)
控制流程：
语法结构： if 判断语句1:
执行语句1
elif 判断语句2:
执行语句2
…
else:
执行语句
break的用法：
i = 0
*while i < len(li):*
if li[i] == 5:
break
print(True) *if li[i] > 5 else False*
*i +=1*
循环可以被终止：
1. 判断语句可以返回 False
2. 通过break终止循环
else的执行条件：
只有在循环不是被break终止的情况下才会执行else中的内容
for循环：
语法规则：
for i in obj：
循环体
range的用法：
for i in range(21):
print(i)
continue的用法：
for i in range(21):
if i % 5 == 0:
continue
print(i)
else：
print('输出结束')
continue跳过本次循环继续循环，break跳出循环
函数参数
-
必备参数：
1 def func(x):
2 print(x)
3
4 func(1)
-
默认参数：
1 def func(x, y=None):
2 print(x)
3 print(y)
4
5 func(1)
6 func(1, 2)
注意：默认参数要位于必备参数列表的后面
-
形参与实参
形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定
1 def sq(data): #形参
2 print(data)
3 ret=123
4 sq(ret) #实参
-
不定长参数：
1 def func(*args, **kwargs):
2 print(args)
3 print(kwargs)
args: 参数包装成一个元组 kwargs： 参数包装成字典
调用1：func(1, 2, 3, a=4, b=5, c=6)
调用2：func(*(1, 2, 3), **{'a': 4, 'b': 5, 'c': 6})
简约不简单的匿名函数
lambda是一个表达式，并不是一个语句
可以用在列表内部
可以用作某些函数的参数
map(function,iterable)第一个参数是函数对象，第二个是一个可以遍历的集合
python的函数式编程
代码中的每一块都是不可变的，由纯函数形式组成（指函数本身相互独立，互不影响，对于相同输入都有相同输出，无副作用）
filter(function,iterable)用函数判断后面列表中的元素，返回布尔值组成的新列表
reduce(function,iterable)用函数计算，最后返回一个值，通常用作累积操作
匿名函数最难理解的地方就是要传入的参数是一个可迭代的对象，
类
class name:
pass
继承：
class A:
pass
class B:
pass
class C extend A
import 与 from...import
在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
异常处理
try/except
异常捕捉可以使用 try/except 语句。
以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。
while True: try: x = int(input("请输入一个数字: ")) break except ValueError: print("您输入的不是数字，请再次尝试输入！")
try 语句按照如下方式工作；
-
首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
-
如果没有异常发生，忽略 except 子句，try 子句执行后结束。
-
如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
-
如果一个异常没有与任何的 excep 匹配，那么这个异常将会传递给上层的 try 中。
一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:
except (RuntimeError, TypeError, NameError): pass
最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。
import sys try: f = open('myfile.txt') s = f.readline() i = int(s.strip()) except OSError as err: print("OS error: {0}".format(err)) except ValueError: print("Could not convert data to an integer.") except: print("Unexpected error:", sys.exc_info()[0]) raise
try/except...else
try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。
else 子句将在 try 子句没有发生任何异常的时候执行。
以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容：
for arg in sys.argv[1:]: try: f = open(arg, 'r') except IOError: print('cannot open', arg) else: print(arg, 'has', len(f.readlines()), 'lines') f.close()
使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。
异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:
>>>def this_fails(): x = 1/0 >>> try: this_fails() except ZeroDivisionError as err: print('Handling run-time error:', err) Handling run-time error: int division or modulo by zero
try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。
以下实例中 finally 语句无论异常是否发生都会执行：
实例
try: runoob() except AssertionError as error: print(error) else: try: with open('file.log') as file: read_data = file.read() except FileNotFoundError as fnf_error: print(fnf_error) finally: print('这句话，无论异常是否发生都会执行。')
抛出异常
Python 使用 raise 语句抛出一个指定的异常。
raise语法格式如下：
raise [Exception [, args [, traceback]]]
以下实例如果 x 大于 5 就触发异常:
x = 10 if x > 5: raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
执行以上代码会触发异常：
Traceback (most recent call last):
File "test.py", line 3, in <module>
raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
>>>try: raise NameError('HiThere') except NameError: print('An exception flew by!') raise An exception flew by! Traceback (most recent call last): File "<stdin>", line 2, in ? NameError: HiThere
用户自定义异常
你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:
>>>class MyError(Exception): def init(self, value): self.value = value def str(self): return repr(self.value) >>> try: raise MyError(2*2) except MyError as e: print('My exception occurred, value:', e.value) My exception occurred, value: 4 >>> raise MyError('oops!') Traceback (most recent call last): File "<stdin>", line 1, in ? main.MyError: 'oops!'
在这个例子中，类 Exception 默认的 init() 被覆盖。
当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:
class Error(Exception): """Base class for exceptions in this module.""" pass class InputError(Error): """Exception raised for errors in the input. Attributes: expression -- input expression in which the error occurred message -- explanation of the error """ def init(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Raised when an operation attempts a state transition that's not allowed. Attributes: previous -- state at beginning of transition next -- attempted new state message -- explanation of why the specific transition is not allowed """ def init(self, previous, next, message): self.previous = previous self.next = next self.message = message
大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
定义清理行为
try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:
>>>try: ... raise KeyboardInterrupt ... finally: ... print('Goodbye, world!') ... Goodbye, world! Traceback (most recent call last): File "<stdin>", line 2, in <module> KeyboardInterrupt
以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。
如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。
文件读取
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
-
filename：包含了你要访问的文件名称的字符串值。
-
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
不同模式打开文件的完全列表：
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |