python语言 -从入门到吃土

一：简介

1、python是一门即面向过程又面向对象的一门编程高级语言：

面向过程：是一种以过程为中心的编程思想，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象：是一种以事物为中心的编程思想，就是讲实体抽象成对象，对象是一系列属性及其相关操作的封装体，比如类。对象就是类的实例。

2、python是解释性语言：

a、高级语言运行的原理：高级语言不能直接运行，必须通过翻译器将高级语言翻译成计算机语言才能运行高级语言。

b、翻译器翻译高级语言的方式：

编译-在程序运行前翻译，通过专门的编译器将程序编译成计算机语言，运行时直接执行编译后的文件。优点：只编译一次；执行效率高。缺点：扩展性差。

解释-在程序运行时翻译，运行一句翻译一句，也需要专门的解释器，解释性语言每执行一次都需要翻译一次。优点：扩展性好，可跨平台执行。缺点：执行一次翻译一次，执行效率低。

c、典型的解释性语言：脚本语言。perl、ruby、python、shell、java。

d、典型的编译型语言：c语言、c++。

3、python特点：

简单易学、免费开源、高层语言、面向对象、可移植性、可扩展性、丰富的库

二：基本概念

1、输入：从标准输入设备（键盘）中读取数据，函数为input()

python2：input可以直接作为命令用,运用时不用加（），用input可以输入字符串和整型数。

python3：input（）当做函数用，用input()输入的内容均为string型；input()可以带参数，例：input('please enter an number!')。

2、输出：在计算机上打印指定的内容，函数为print()。

例：

print('HelloWorld!')

3、常量：

常量是一旦定义就不能更改的量，python中通常用定义常量类来实现

4、变量：

a、相对于常量而言，变量是定义后还能改变的量，通常先定义一个变量名，再给他赋个值，如：a = 10,示例中a为变量名，=为赋值运算符，10为给变量赋的值。

b、变量的数据类型根据其所赋的值来决定，如果值是整型，那么变量就是整型，如果值是字符串型，那变量也是字符串型。

5、基本数据类型：

整数：int(）、小数:float()、字符串:str()、布尔值:bool()-True false。

6、类型转换：

a、整型和浮点型可以转换为其他数据类型，但0转换为布尔值后值为False。

b、字符型的数字和小数可以转换为整型或者浮点型，但类似英文字母之类的字符串不能转换为整型或者浮点型，可以转换为布尔型，有字母时转换为布尔值后值为True，将None转换为布尔值时，值为False。

c、布尔值与其他类型都可转换，True转换为整型值为1，False转换后为0，True转换为字符串型后值为True。

7、字符串格式化：

a、%格式化   

%[(name)][flags][width].[percision]typecode ——[]中的参数为非必填，同时指定多个name时，后面跟的值需要用字典格式。

例：
打印出“董事长：张三，总经理：李四”
a="董事长：%（dname)s，总经理：%(zname)s"%{"dname":"张三","zname":"李四"}
print(a)

typecode为必填 ——常用的typecode：%s、%r、%d、%f

b、.format()格式化

"XXXX{},XX{},X{}".format("","","")——XXX后面的{}中可以设置要显示的格式，{}花括弧内的格式也有s/d/f几种常见格式限定方式，format（）括弧内可以指定参数，参数可以是字符串、整型数、列表、字典等，format（）括弧内如果有两个参数，第一个默认索引为0，第二个参数的索引值默认为1，当然可以指定参数并给其赋值。

例：
打印出“姓名为：张三 年龄为：24
1/ a='姓名为：{} 年龄为：{}'.format('张三',24)
print(a)
2/ a='姓名为：{name} 年龄为：{age}'.format(name='张三',age=24)
print(a)

8、运算符与表达式：

a、算术运算符

+、-、*、**（求幂）、/、//（取结果的整数部分，不具备4舍5入功能）、%（取被整除后余下的数）

b、逻辑运算符

与 and、或 or、非 not

c、按位运算符，针对2进制数

>>右移、&按位与、| 按位或、^ 按位异或、~ 按位翻转

d、比较运算符

<、<=、>、>=、==、!=

e、赋值运算符

=、+=、-=、*=、/=、**=、%=、//=

优先级：算术>赋值运算符>按位运算符>比较运算符>逻辑运算符

三：python控制流语句

1、python控制流语句：

程序设计的三种结构：顺序、条件、循环。

a、条件语句：(注：全用if执行效率更低，而用if...elif。。。else效率更高)

多种假设并列存在：语句全部用if开头。

if True:
     pass
if True:
     pass
if  True:
      pass

只有两种假设，如果条件不成立，执行else —— 一个if.........else:.....

if True:
    pass
else:
    pass

多种条件判断，如果第一种条件成立，略过后面的判断 —— if.......:elif......:elif.....:else:

if True:
    pass
elif True:
    pass
else:
    pass
上述语句中如果if条件成立，程序不运行elif和else语句

b、循环语句：

while循环：适用于未知循环次数。

while后跟条件，通过限制条件来跳出循环。

a =0
while a
    a+=1
    no =input('请输入一个数')
    if int(no)>=10:
        print('>=10')
    elif int(no)=0:
        print('the number between 0 and 10')
    else:
        print('the number 

while后跟布尔值True或False，通过break语句跳出循环。

whiel True:
    pass

for循环：适用于已知循环次数，通常用于遍历某个集合的循环。经常使用的函数：

range()：取值范围，但（）中的值不包含最大值。

例：
range（1,10）的取值范围是1-9，不包含10

len()：计算集合长度，集合可能是字符串、列表或字典

例：
a=[1,2,3,4,5,6]
len(a)经过计算后的值为6

继续执行和跳出循环命令：continue、break

c、顺序语句：

系统默认自上而下运行语句，这种情况较顺序执行。

四：函数

1、函数的定义和调用

定义：def 函数名（x,y）：

调用：函数名（x的值,y的值）：

2、形参：函数定义的参数，为函数传递值

上面（）中的x和y叫形参：

a、调用函数时，可以按照x和y的位置来传递参数

例：为fun(x,y)传递参数
fun(1,2)中x=1,y=2

b、定义函数时，也可以给函数的部分形参指定默认值

例：定义函数时，给函数的形参指定默认值
def fun(x,y=4):
    result = x+y
    return result
fun(x=4)# 因为y已设为默认值，所以调用时可以不再传入参数，当然如果y值有变化也可以给y传参数

c、调用函数时，可以不按x和y的固定位置来传参

例：不按照x和y的固定位置传参
已定义函数fun(x,y)
调用时：fun(y=5,x=3)一样可以

3、全局变量

a、在整个.py文件中申明的变量。

b、注：全局变量不能在函数内部直接使用，如果定义了全局变量a,又在函数内定义了变量a，那么前一个a为全局变量，可以在整个.py文件中函数、类以外的地方使用；后一个a为函数内部定义的局部变量，仅能在函数内部使用，在函数外使用无效。如果要在函数内部调用（引用）全局变量，需要用global命令，调用后全局变量的值如果有修改，那么作用于其他地方的该全局变量值也会随之修改。

例：在函数内定义的局部变量不能作用于函数外
#encoding:utf-8
def fun():
    num=20
    print('函数局部变量值为%d'%(num))
num = 100
print('全局变量num的初始值为：%d'%(num))
fun()
print('全局变量num的最后值为：%d'%(num))
例：全局变量不能直接作用于函数内
#encoding:utf-8
def fun(x):
    num+=x  #函数内直接引用全局变量num，且让num+x后赋值于num。
    print('函数局部变量值为%d'%(num))
num = 100
print('全局变量num的初始值为：%d'%(num))
fun(20)   #程序运行至此时会报fun()函数中的num没有定义的错误。
print('全局变量num的最后值为：%d'%(num))
例：如果需要引用全局变量，需要使用global命令，且引用后全局变量值会随之更改
#encoding:utf-8
def fun(x):
    global num
    num+=x
    print('函数局部变量值为%d'%(num))
num = 100
print('全局变量num的初始值为：%d'%(num))
fun(20)
print('全局变量num的最后值为：%d'%(num))

4、局部变量

a、在.py文件的函数中定义的变量。

b、将局部变量作为另一个函数的引用变量时用global命令是不行的，在python3中可以使用nonlocal 命令。

例：nonlocal的用法
#encoding:utf-8
def fun():
    num=2
    def fun1():
        nonlocal num
        num*=2
        print('子局部变量num值为：%d'%(num))
    print('局部变量num值为：%d'%(num))#可以试试把这句放在return语句之后，看看有什么奇迹？
    return fun1()  
fun()

5、return

a、返回函数内指定变量或值，并将指定值传递给运行后的函数，但并不具备打印功能。

b、结束函数内语句的执行，代码执行到return语句之后不再执行return之后的函数内部语句。

五：模块

1、定义

python中的一个包含函数、变量的.py文件，通过对文件的调用，我们可以实现文件中函数或变量的重用。

2、调用方式

a、from XXX文件名 import 函数名或变量名：可以直接运用函数或变量。

例：从随机模块中导出随机抽取1个整数值的方法
from random import randint
a= randint(1,10) #从1-10中随机抽取1个整数，包含1和10

b、import XXX文件名：需要同过文件名来引用函数或变量。

例：调用随机模块
import random
a= random.randint(1,10)
#调用随机模块下的randint()方法来随机抽取包含1和10的10以内整数的1个值；

3、随机模块random介绍

random下包含3个方法：

a、randint(x,y)：随机抽取指定范围内的一个整数值，包含上限y、下限值x。

b、sample(x,y)：随机抽取出指定范围内x中y个元素。

c、choice(x)：随机在指定范围内x中抽取1个元素。

4、调用模块后取别名

from random import randint as rdi #给导出的randint取个别名叫rdi。

import random as rd #给导出的模块random取别名rd。

5、自定义模块

当我们在.py文件中创建了函数或变量后，.py文件就可以看成是我们自定义的模块。

注：引入自定义的模块，需要放在python运行环境变量路径下或与当前运行程序路径下。

6、查询某个模块下有哪些函数、类或变量的命令：dir()

用法：dir(模块名)：返回该模块的名称列表，如果括号内没有模块名，则返回当前模块的名称列表。

六：数据结构（python内建三种数据结构）

1、列表（list）

a、定义

以“[]”括起来，列表中的元素以“,”区分；列表中的元素可以是任意数据类型，也可以是不同数据类型的组合，也可以列表、元组、字典作为列表元素。

例：
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
for i in a:
    print(i)

b、python内置列表函数

len(list)：求列表内元素的个数

max(list)：返回列表中元素的最大值

min(list)：返回列表中元素的最小值

list(seq):将序列转换为列表：序列可以是元组、字典、字符串，转换成列表后字符串内的字符以','分隔。

c、列表方法

list.append(obj)：默认往列表末添加元素

list.count(obj)：统计指定元素在列表中出现的次数

list.extend(seq)：在列表末追加一个列表

list.index(obj)：返回指定元素在列表中的索引位置

list.insert(index,obj)：在指定位置插入指定元素

list.pop([index])：删除指定索引位置的元素，【index】代表数字，默认从0开始计数

list.reverse()：反向列表元素

list.sort()：对列表元素排序

注：函数和方法的区别：函数时直接可以用的，方法是需要对象来调用的
d、列表通过索引访问

2、元组

a、用()来标识一组数据，元组内的值不可更改，一般用元组来定义一组不能更改的值。

b、空的元组由（）标识，但若要定义元组内的唯一元素，需要在元素后加‘，’以区分带（）的表达式。

3、字典

a、空的字典由{}标识，字典由若干个键值对组成，1个键值对为字典的元素，元素间由‘，’标识。

例：定义一个变量为字典
uname = {'name1':'zhangsan','name2':'lisi','name3':'wangwu'}

b、我们访问字典一般是访问字典的键，通过字典的键来获取对应的值。

4、序列

a、列表、元组、字符串都是序列。序列的特点：有序的，可以通过索引来调用对应元素。
b、字典不是序列的原因是字典中的键是无序的。
c、序列的两个特征，注：只有序列可以切片操作，字典不能进行切片。

索引操作符：

利用索引可以从序列中抓取指定的元素。注：python的序列中索引值0代表序列中的第一个元素位置；索引值可以为正数也可以为负数，索引为正数时，代表序列元素从左到右的位置，索引为负数时，代表序列元素从右到左的位置。

例：找出列表a中索引值为2对应的元素
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
print(a[2])#a[2]对应的元素为1.2
例：找出列表a中倒数第2位的元素
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
print（a[-2]）

切片操作符：

可以从序列中获取序列的切片，即一部分序列。

例：返回列表a中第2至第5个元素的列表
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
print(a[1:5])

切片操作符同样是序列名后跟一个方括号，方括号中有一对的数字，并冒号分隔，第一个数表示切片开始的位置，第二个数表示切片结束的位置，注意开始的位置包含在切片中，但结束的位置不包含在切片中。

切片操作符中的数字对，数是可选的，冒号是必须的。如果不指定第一个数，切片从序列首开始，如果不指定第二个数，切片从序列尾结束（包含），都不指定则返回整个列表的一个拷贝。

同样的切片操作符中的数字可以为负数，表示从序列尾开始计算。注：[]内：前面的值不能大于：后面的值，否则返回一个空列表。

例：返回列表a倒数第4位到列表尾的列表
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
print(a[-4:])

5、遍历

序列和字典可以用for循环遍历    注：遍历字典时，获取的是字典的键而不是对应的值

d={'hunter':'man','hunterman':'woman'}

for i in d:
    print(i)

6、修改

a、元组和字符串不能修改
b、列表和字典可以修改，修改时，直接通过索引定位指定元素，然后给其赋值

例：
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
a[2]=2
print(a)
d={'hunter':'man','hunterman':'woman'}
d['hunterman']='zhangsan'
print(d)

7、新增

a、元组和字符串不能修改，所以不能新增
b、向列表中新增元素，使用.append()方法

例：
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
b='abcd'
a.append(b)
print(a)

c、向字典中新增元素，直接给新增的键赋值

例：
d={'hunter':'man','hunterman':'woman'}
d['user'] = 'zhouwei'
print(d)

8、删除

a、删除列表元素

调用列表方法

例：
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
a.pop(6)

调用命令 del

例：
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
del a[6]
print(a)

b、删除字典元素

调用命令del 后面跟字典的变量名d['键名']，删除指定的键值对。

例：
d={'hunter':'man','hunterman':'woman'}
del d['hunterman']
print(d)

9、字符串方法（https://www.cnblogs.com/fyknight/p/7895894.html#_lab2_0_0）

例：a-w

a、字符串转列表方法

将整个字符串转成列表的一个元素：''.split()，括号内可以没有任何内容，也可以指定特定的分隔符：如','、' '等。

例：没有指定分隔符
b='abcd'
f=b.split()
print(f)
例：指定以','作为分隔符
b='a,b,c,d'
f=b.split(',')
print(f)

将字符串中的每个字符转成列表中的每个元素：list(str)，str代表字符串，默认以‘,’分隔。

例：
b='abcd'
e=list(b)
print(e)

b、列表转字符串方法‘ ’.join(seq),seq为列表，‘ ’内可以填：‘，’、空格等你想要用作分隔的分隔符。

例：不指定分隔符

a = ['123','456','789','112']
b= ''.join(a)
print(b)
例：指定以‘，’作为分隔符
a = ['123','456','789','112']
b= '，'.join(a)
print(b)

注：使用''.join(seq)方法时，seq列表中的元素必须是字符串类型，否则不能用。

例：将列表a中的元素转换成字符串
a=[1,'x',1.2,True,[1,2,3,4],(1,2,3,4),{'zhangsan':19}]
b = [str(i) for i in a]#将列表a中非字符串型的元素转化为字符串
print(b)
c=''.join(b)
print(c)

c、''.index('obj',x,y)

返回指定元素的索引值。

x代表从字符串的第x+1位置开始搜索，y代表搜索到字符串的y+1位截止

例：
a= 'hello world!'
b= a.index('l',5，11)
print(b)

如果不指定x,y默认从字符串的第一位开始从左至右搜索，到字符串尾结束

例：
a= 'hello world!'
b= a.index('h')
print(b)

如果指定元素在字符串中不存在，会返回错误提示

例：
a= 'hello world!'
b= a.index('x')
print(b)

如果在搜索范围内有多个指定元素存在，默认返回第一次出现的元素索引值（顾头不顾尾）

例：
a= 'hello world!'
b= a.index('o',3,7)
print(b)

指定元素为一个字符串时，返回元素首字符的索引值

例：
a= 'hello world!'
b= a.index('world')
print(b)

d、''.find('obj')

返回指定元素的索引值，如果没找到则返回-1。

例：
a= 'hello world!'
b= a.find('x')
print(b)

其他项与.index(obj)用法类似。

例：
a= 'hello world!'
b= a.find('hello')
print(b)

e、''.count('obj')

返回指定元素在字符串中出现的次数

例：
a= 'hello world!'
b= a.count('o')
print(b)

如果没找到则返回0

例：
a= 'hello world!'
b= a.count('x')
print(b)

f、''.strip('obj')

移除字符串左右两边的指定字符，如果括号内没有指定字符，默认移除字符串两边的空格，并返回移除后的字符串。

例：移除字符串a左右两边的空格
a= '  hello world!  '
b= a.strip()
print(b)
例：移除字符串a左右两边的*
a='**************hello world!**************'
b = a.strip('*')
print(b)
例：移除字符串a左右两边的！
a= 'hello world!'
b= a.strip("!")
print(b)

g、''.replace('obj','Nobj',Num)

将字符串中指定元素替换成Nobj，并指定替换次数

例：
a='the god love me!'
b = a.replace('t','T')
print(b)

Num用于当字符串中有多个需要替换的对象时，来限定替换的次数

例：
a = 'the quick fox jump over a lazy brown dog!'
b= a.replace('o','O',2)
print(b)

当要替换的内容不存在时，不报错，直接返回原字符串内容

h、''.format()

格式1：“字符串-｛｝-字符串-｛｝”.format(“内容1”，“内容2”)

例：
hello = 'hello {},my name is {}'
fm = hello.format('everyone','hunter')
print(fm)

格式2：“字符串-｛1｝-字符串-｛0｝”.format(“内容1”，“内容2”) ，注：花括弧中的是format()括号中的索引值，默认以0开始计数

例：
hello1 = "hello {2},my name is {0},what's your {1}?"
fm1 = hello1.format('john','name','hunter')
print(fm1)

格式3：“字符串-｛变量名1｝-字符串-｛变量名2｝”.format(变量名1 = “内容 ”，变量名2 = “内容2”)

例：
hello2 =  "hello {name1},my name is {name2},what's your {name3}?"
fm2= hello2.format(name1='hunter',name2 = 'john',name3 = 'name')
print(fm2)

i、''.encode(‘编码格式’)

指定字符串的编码格式
j、''.decode('编码格式')

指定字符串的解码格式

~~~ 一般情况下，用什么格式 编码就要用什么解码，否则要乱码

例：
a = '我是中国人'
b= a.encode('utf8')
c = b.decode('utf8')
print(c)

k、''.startswith('obj')

判断字符串是否以指定的字符开头，如果是返回True，如果不是返回False

例：判断是否以hello开头，是就返回True,不是就返回False
a='hello world'
b=a.startswith('hello')
print(b)

判断字符串是否以指定位置的指定字符开头，如果是返回True，如果不是返回False

例：
a='hello world'
b=a.startswith('w',6)
print(b)

l、''.endswith('obj')

判断字符串是否以指定的字符结尾，如果是返回True，如果不是返回False，这个方法不能判断指定位置的元素

例：判断是否以hello结尾，是就返回True,不是就返回False
a='hello world'
b=a.endswith('hello')
print(b)

m、''.upper()

将小写的字符串全部转换为大写，注：括号内不跟字符

例：
a='Hello world'
c=a.upper()
print(c)

n、''.lower()

将小写的字符串全部转换为小写，注：括号内不跟字符

例：
a='Hello world'
c=a.lower()
print(c)

o、''.title()

将字符串中所有单词的首字母转换为大写，其余部分改为小写，并返回转换后的字符串

例：
a='hello world'
d = a.title()
print(d)

p、''.swapcase()

将字符串中的大小写相互转换，并返回转换后的结果

例：
a='hello world'
d = a.title()
print(d)
e = d.swapcase()
print(e)

q、''.center(num,'*')

返回一个指定长度位置的字符串居中显示，字符串自身长度小于指定长度时，以指定的”*“填充剩余长度，如果不指定填充符，默认以空白填充，字符串自身长度大于指定长度时，即便指定了填充字符，填充字符也不会显示

例：不指定填充符，居中打印
s = 'i love winter'
s1 = s.center(30)
print("开始-》"+s1+"《-结束")
例：指定填充符居中打印
s = 'i love winter'
s1 = s.center(30,"*")
print("开始-》"+s1+"《-结束")
例：指定显示长度小于字符串本身长度，且指定填充符
s = 'i love winter'
s1 = s.center(10,"*")
print("开始-》"+s1+"《-结束")

r、''.capitalize()

返回一个首字母大写，其他字母小写的字符串

例：让字符串中的首字母大写，其他字母小写显示
s = 'my name is ZHouWei'
s1= s.capitalize()
print(s1)

s、''.isdigit()

判断字符串是否由纯数字组成，并返回布尔值，如果是纯数字，返回True

例：判断一个字符串是否由纯数字组成，期望返回False
s = 'my name is ZHouWei'
s1= s.capitalize()
print(s1)
s2 = s.isdigit()
print(s2)
例：判断一个字符串是否由纯数字组成，期望返回True
a= '123456'
b = a.isdigit()
print(b)

t、''.isalpha()

判断字符串是否由纯字母组成，并返回布尔值，如果是纯字母，返回True。注：如果字符串中间有空格会返回False

例：判断字符串是否为纯字母
s = 'thisisclock'
s1 = s.isalpha()
print(s1)
例：判断字符串是否为纯字母
s = 'this is clock'
s1 = s.isalpha()
print(s1)

u、''.isalnum()

判断字符串是否以字母或数字组成，如果是，返回True，如果不是，返回False,字符串中有空格,返回False

例：
s = 'this5isclock'
s1 = s.isalpha()
print(s1)
s2 = s.isalnum()
print(s2)
例：
s = 'this isclock'
s1 = s.isalpha()
print(s1)
s2 = s.isalnum()
print(s2)

v、''.isspace()

判断字符串是否全部由空格组成，如果是，返回True,如果不是，返回False

例：
s = 'haa  '
s1 = s.isspace()
print(s1)
例：
s = '   '
s1 = s.isspace()
print(s1)

w、''.istitle()

判断字符串首字母是否为大写，且其他为小写，如果是，返回True，如果不是，返回False，中间不能有空格

例：
a = 'Ilovemycountry'
b = a.istitle()
print(b)
例：
a = 'IlovemyCountry'
b = a.istitle()
print(b)

七：文件处理

1、读

a、读文件内容：

先打开文件 —— 打开方式 —— 只读（缺省或“r”）、替换（"w"）、追加（"a"）

读文件内容 —— 读取方式 —— 一次性读取文件全部内容，并返回字符串格式（reade()）；一次只读取文件的一行内容，并返回字符串格式（readeline()）；按行读取文件所有内容，并以列表格式返回（readelines()）。
b、新建文件

需要新建一个文件时，必须以“w”方式打开文件，文件路径可以自定义 —— open('文件名','w')
c、关闭打开的文件，释放资源

x.close()x为打开文件时所赋值的变量

2、写

a、先打开文件 —— 打开方式 —— 全覆盖（open('文件名','w')）、追加数据（open('文件名','a')）
b、往文件中写数据 —— 写入方式 —— 写入字符串（write(s) s为字符串）、写入列表（writelines(list)list为列表）

八：Python标准库

1、syx模块

a、sys.version变量提供python版本信息
b、sys.platform变量提供python运行的平台信息
c、sys.exit()函数提供退出程序功能，参数为0时表示正常退出
d、sys.getdefaultencoding()函数提供获取系统当前编码功能，一般为ascii
e、sys.setdefaultencoding()函数设置系统默认编码（python 3已经没有该函数，默认编码格式为unicode）
f、sys.getfilesystemencoding()函数获取文件系统使用编码方式

2、os模块

a、os.name变量指示正在使用的平台
b、os.getcwd()函数得到当前的工作目录
c、os.getenv()和os.putenv()函数分别用来读取和设置环境变量
d、os.listdir()函数返回指定目录下的所有文件和目录名
e、os.remove()函数用来删除一个文件不能删除目录

3、math模块

实现了许多对浮点数的数学运算函数

4、ctmah模块

实现了许多用于复数运算的函数

5、string模块

提供了许多处理字符串类型的函数

6、time模块

提供了一些处理日期和一天内时间的函数

7、types模块

a、包含了标志解释器定义的所有类型的类型对象
b、types.IntType整数 types.FloatType浮点数 types.StringType字符串
c、types.ClassType类 types.Instance对象
d、type()返回参数的数据类型

九：数据库连接

1、安装pymysql库

Python连接MySQL数据库，使用的是第三方库pymysql3 ，需要单独安装

安装步骤：

a、将PyMySQL-master.zip解压到python的安装目录下

b、进入到PyMySQL-master目录下

c、运行命令：Python setup.py install

d、安装完成后即可通过import导入pymysql模块

2、连接

a、connect函数的常用参数：user(用户名)、password(用户密码)、host(主机名)
b、database(数据库名)、port(端口)
c、connect函数返回连接对象，这个对象表示目前和数据库的会话
d、connect函数返回的连接对象方法

close()-关闭连接，关闭后，连接对象和它的游标均不可用；commit()-提交事务，对数据库做的数据更改等事务只有提交才会生效；rollback()-回滚事务，撤销所有未提交的事务；cursor()-返回连接的游标对象。

3、游标

游标用来执行命令的方法

a、callproc()：用来执行存储过程，接收的参数为存储过程名和参数列表，返回值为受影响的行数
b、execute()：执行单条sql语句(可能带有参数)，返回值为受影响的行数
c、fetchall(): 接收执行结果，默认接收上一条execute语句的结果
d、close()：关闭游标

十：网络编程

1、urllib

a、互联网基本原理是基于“请求-响应”模式，获取互联网上的资源需要发出请求，即URL
b、使用urllib模块urlretrieve()方法下载文件 —— urlretrieve(url,[filename,reporthook])

参数url代表资源路径；参数filename指定本地保存路径；参数reporthook是一个回调函数，当连接上服务器、以及相应的数据库传输完毕时会触发回调，可以利用来显示下载进度

2、json

3、socket（套接字）

a、服务器套接字 —— 服务器socket函数

bind(address)方法将套接字绑定到地址，参数address以元组(host，port)的形似表示地址；

listen(backlog)方法开始监听TCP传入连接，参数backlog为操作系统可以挂起的最大连接数，至少为1；

accept()方法接收TCP连接并返回元组(conn，address)，conn是新的socket对象，服务器必须通过它与客户通信，address是客户的地址。
b、客户端套接字 —— 客户端socket函数

connect(address)方法连接到指定地址的套接字，参数address格式为元组(host,port)地址；

connect_ex(address)方法与connect()方法相同，但是成功返回0，失败返回errno。
c、公共socket函数

recv(bufsize)接收TCP数据，参数bufsize指定接收的最大数据量，结果以字符串形式返回；

send(string)发送TCP数据，参数string是字符串，返回值是要发送的数据量；

sendall(string)完整发送TCP数据，在返回之前会尝试发送所有数据；

recvfrom(bufsize)接收UDP数据，返回值是(data,address),address指明发送方地址；

sendto(string，address)发送UDP数据，参数中也需指明address(接收方地址)；

settimeout(timeout)设置套接字操作的超时时间，参数timeout是浮点数，单位为秒；

close()关闭套接字。
d、socket()方法的格式：socket（family，type）

family参数代表地址家族，可以是AF_INET或AF_UNIX，AF_INET代表IPv4地址，AF_UNIX只能用于单一的Unix系统进程间通信；

type参数代表套接字类型，可以是SOCK_STREAM或SOCK_DGRAM，SOCK_STREAM代表流套接字，应用于TCP，SOCK_DGRAM代表数据报套接字，应用于UDP

注：流套接字和数据报套接字的区别：
    1、流套接字区分服务器和客户端，数据报套接字不区分
    2、流套接字适合传输数据量大的，数据报套接字适合传输数据量小的
    3、客户的流套接字单向传递，数据报套接字可以接收任何方向的数据，并可以向任何地址发送数据报
    4、流套接字使用时不需考虑底层细节，依靠TCP协议进行可靠的数据传输
数据报套接字依靠UDP协议，数据传输效率高，但需要考虑底层细节，在代码中保证数据的可靠传输
    5、流套接字依靠TCP协议建立好连接后发送数据，不需要指定地址
数据报套接字依靠UDP协议发送数据，每次都需要指定发送给谁
e、TCP服务端和客户端
    编写服务端socket
    编写客户端socket
    循环通信--服务端
    循环通信--客户端

十一：正则表达式

1、正则表达式的特点

a、灵活性、逻辑性、功能性非常强
b、可以迅速地用极简单的方式达到字符串的复杂控制
c、对于刚接触的人，比较晦涩难懂

2、re模块

a、re.findall()
b、re.match()
c、re.search()
re.match()、re.search()区别：
re.match( )尝试从字符串的起始位置匹配一个模式，如果不匹配就返回none
re.search( )扫描整个字符串并返回第一个成功的匹配
d、使用符号命令和规则
使用符号^表示匹配以abi开头的的字符串返回,也可以判断字符串是否以abi开始的；
使用符号$符号表示以gbi结尾的字符串返回,也可以判断是否以字符串gbi结束；
[...]的意思匹配括号内a和f，或者b和f，或者c和f的值返回列表；
'\d'是正则语法规则用来匹配0到9之间的数返回列表,需要注意的是11会当成字符串'1'和'1'返回而不是返回'11'这个字符串；
解决的办法就需要取几位数就写几个\d；
‘\D’表示不要数字，也就是除了数字以外的内容返回；
‘\w’匹配字母（包含汉字）、数字及下划线；
‘\W’匹配除匹配字母、数字及下划线以外的符号；
表示匹配括号内里面的内容，这里.*是正则贪婪匹配语法，就是最大范围的匹配准则；
.*?，非贪婪模式；
re.I(大写的i)表示匹配时不区分大小写；
re.S(大写)这样代表匹配包括换行符在内的所有字符。

3、元字符

    字符
    预定义字符集
    数量词
    边界匹配
    逻辑、分组
    特殊构造（不作为分组）

十二：面向对象

面向过程编程是一种以事件为中心，面向对象编程是一种以事物为中心
1、类
2、对象
3、属性
类属性：公有属性（类的所有实例都可以访问）；私有属性（只能在类中访问）
实例属性：类的具体实例所拥有的属性
4、方法
类方法：需要用修饰器
实例方法
构造方法： 构造方法：__init__(前后是双下划线)
5、三大特性
封装，继承，多态
第一步：将内容封装到某处
第二步：从某处调用被封装的内容

十三：异常处理

异常处理结构

1、

try:
..............
except:
............

错误类型
    AttributeError
        特性引用或赋值失败时引发
    NameError
        在找不到名字时引发
    IndexError
        在使用序列中不存在的索引时引发
    Exception
        所有异常的基类
    KeyError
        在使用映射中不存在的键时引发
    IOError
        试图打开不存在文件时引发
    SyntaxError
        在代码为错误形式时引发
    TypeError
        在内建操作或者函数应用于错误类型的对象时引发
    ValueError
        在内建操作或者函数应用于正确类型的对象，但是该对象使用不合适的值时引发
    ZeroDivisionError
        在除法或者模除操作的第二个参数为0时引发

2、

try…finally

finally语句表示最后,和try…except…else一起使用

以上就是python的基本知识，谢谢，个人总结的部分知识点，有不足或者错误请指出。