python入门

1.数据类型

代码	备注
str()	文本型,字符串
int()	整数型
bool()	逻辑型,布尔值(True,False) [None、空(即 [ ],( ) ," ",{ })、0 都为False]
float()	小数型,浮点型
tuple()	元组(类似数组,不能修改成员)
list()	列表(类似数组,成员可以更改)
dict()	字典(类似json格式)
set()	集合(会把传入的序列去重复)
bytes()	字节集,二进制(不可变的序列)
bytearray()	字节集,二进制(可变的序列)

2.运算符号

代码	备注
+	加
-	减
*	乘
/	除
//	整除(相除返回整数部分,10//3=3, 10.0//3.0=3.0)
%	取模(取除法的余数,10%5=0, 10/2.5=0.0, 10/3=3)
**	幂(取次方,10**3=1000)
=	赋值
==	比较
!=	不等于
<>	不等于
+=	等同于 a = a + x (数字,文本,列表等都支持)
-=	等同于 a = a - x
*=	等同于 a = a * x
/=	等同于 a = a / x
%=	等同于 a = a % x
**=	等同于 a = a ** x
//=	等同于 a = a // x
>	大于
<	小于
>=	大于等于
<=	小于等于
and	且 (所有条件必须都满足才为True, 1 = 1 and 2 = 2 为True)
or	或 (有一个条件满足则为True, 1 = 1 or 2 > 2 为True)
not	取反 (not True == False)
in	是否存在 ( 'a' in ['1','a'] 为 True,检测序列中是否存在该成员)

3.其他常用命令

代码	备注
del	删除 (可以直接删除成员跟变量)
pass	填充 (不做处理的地方可以直接填充)
print()	输出,打印 (等同调试输出)
return	返回
break	跳出 (循环中使用,直接跳出循环,执行循环下面的代码)
continue	跳过 (循环中使用,跳过本次循环,继续下一次循环)
global	引用 (函数内修改外部变量需要先引入, global 变量名)
while	判断循环 ( while True: 则为死循环)
lambda	匿名函数 (a = lambda x,z: x + z ,a(5,1) 结果为6,将变量定义成函数x,z为定义接受的参数)
assert	断言 (用法: assert 条件, 条件为True时正常继续执行,为False则弹出报错)

4.更换pip源

归属	源地址
清华	https://pypi.tuna.tsinghua.edu.cn/simple/
中科大	https://pypi.mirrors.ustc.edu.cn/simple/
阿里云	https://mirrors.aliyun.com/pypi/simple/
豆瓣	https://pypi.douban.com/simple/

Python通常的库都是直接使用pip下载 系统默认的时常会出现下载慢或无法下载的情况,此时就可以尝试更换pip源,一般装完后都会直接更换掉。

更换默认pip源地址 在cmd窗口里执行：pip config set global.index-url 源地址

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple/

一次性单独某个库使用指定源下载：pip install 库名 -i 源地址

pip install django -i https://pypi.tuna.tsinghua.edu.cn/simple/

5.安装模块

模块 = 包 =库 = "强行达成共识", 网上叫法不一,知道是啥就好了

pip常用命令

命令	备注
pip --help	获取帮助信息
pip --version	获取pip版本跟路径
pip install -U pip	升级pip版本
pip install django	安装模块(django是模块名)
pip install django==2.0.2	安装指定版本的模块(django是模块名,2.0.2是版本号,这里可以使用 ==,>,<,>=,<=)
pip install --upgrade django	升级模块(django是模块名)
pip install --upgrade django==3.1.0	升级模块到指定版本(django是模块名,3.1.0是版本号,这里可以使用 ==,>,<,>=,<=)
pip uninstall django	卸载模块(django是模块名)
pip search django	搜索模块(django是模块名)
pip show django	显示模块信息(django是模块名)
pip list	显示已安装的所有模块及版本号
pip list -o	显示可升级的模块名

电脑只装一个Python3版本的使用pip跟pip3好像是没啥区别

如果装了Python2跟Python3 同时有 pip,安装模块时可以用下面的方法：

Python2:

python2 -m pip install 模块名

Python3：

python3 -m pip install 模块名

6.引用模块

在 Python 用 import 或者 from...import 来导入相应的模块。

import os    #单独导入整个os模块
#import os,sys    #同时导入os,sys多个模块
print(os.getcwd())    #调用os模块里的getcwd函数


import os as 系统    #导入整个os模块,更改调用名为 系统,这种导入可以方式多个模块出现相同
print(系统.getcwd())    #调用os模块里的getcwd函数,因为使用了as,所以调用时要使用 系统


from os import *    #导入整个os模块,不同的是这里导入后引用时不需要带os
print(getcwd())    #from导入的直接使用函数名


from os import getcwd    #从OS单独导入getcwd函数
#from os import getcwd,rename    #从OS导入getcwd,rename多个模块
print(getcwd())    #from导入的直接使用函数名


def text():
    import os    #子程序内可以单独导入模块
    pass

从指定目录下导入

#导入相同目录下(运行目录下)的pyec.py文件
import pyec
form pyec import *
form . import pyec #.为当前目录


#导入相同目录下(运行目录下)"模块"文件夹里的pyec.py文件
import 模块.pyec
form 模块 import pyec
form .模块 import pyec
form 模块.pyec import pyec

#导入文件夹内的py文件夹时,文件夹内可能需要创建 __init__.py 文件

7.函数运行

创建个py文件,开始敲BUG

#Python的缩进是用四个空格或TAB键,所以定义函数 循环的时候没有那些大小括号包裹
#缩进这个用一会基本就能适应,在Pycharm里也会显示虚线

a = 10
def 子程序名(参数1, 参数2):  # def 是声明函数(子程序)
    print(a,参数1,参数2) #a是外面的变量,函数内如果没有提前定义就会使用外面定义的变量


子程序名( "第一个", True)

#然后直接运行,会调试输出:10 第一个 True
#Python会自上而下运行代码,除非你的程序只有这一个py文件不然这样写是不可行的
#如果有另一个py程序引入你这个py文件也要调用你这个子程序,那么他导入你这个模块运行的时候就会先执行一次了

#规范点的

def 加密_md5(data):
    return "假装加密好了"

if __name__ == '__main__':
    print(加密_md5("123456"))

#在文件底部添加 if __name__ == '__main__':
#把要运行或调试的内容写在这个if里面
#这个if是判断当前py文件是否为直接运行,其他程序引用当前py文件的时候就不会执行这里面的代码
#简称当前文件在直接运行的情况下才执行里面的代码

引用变量

a = 10
def text():
    print(a)
text()
#输出结果:10
#在函数内为提前声明且不对变量进行删改操作时能直接引用

a = 10
def text():
    a = 50
    print(a)
text()
print(a)
#输出结果:50 10
#函数内声明之后函数内优先使用里面定义的变量,因为没有引入外面的变量 a 所以外面的变量值不受影响

a = 10
def text():
    global a
    a = 50
    print(a)
text()
print(a)
#输出结果:50 50
#在函数内使用global引入变量后就可以对该变量进行删改操作了

def text():
    return 10,"文本"    #返回多个参数
a = text()
print(a)

#输出结果：(10,"文本")
#函数返回多个返回值的时候如果使用一个变量接收则接收到的是一个元组,可以自行用索引取出指定的值
#返回的第一个返回值 = a[0] ,返回的第二个返回值 = a[1] 

def text():
    return 10,"文本"    #返回多个参数
a,b = text()
print(a,b)

#输出结果：10 "文本"
#返回多个返回值也可以用相同数量的变量逐一接收

8.列表数组

元组-tuple (不能改动)

元组1 = (1, 2, 3, 4, 5 )
元组2 = ('a', 10, [1,2], {"id":"1"})
元组3 = "a", "b", "c", "d"
元组4 = tuple((1,2,3,4))
元组5 = tuple("生成元组") #('生','成','元','组')自动逐字分割
元组6 = ("a",) #当元组只有一个成员时必须成员后面必须加个逗号：(1,)

#元组是以()包起来的数据
#元组定义后就无法修改删除成员,不过可以使用拼接增加长度,或者使用del删除整个元组

新元组 = 元组1 + 元组2
#新元组：(1, 2, 3, 4, 5, 'a', 10, [1, 2], {'id': '1'})

del 元组1
#元组1变量被删除

#取值,第一个成员的索引从0开始
成员1 = 元组2[0]
成员2 = 元组2[1]
成员 = 元组2[1:3]#索引是从0开始的,所以这里是取第二个跟第三个的值(10, [1,2])
成员 = 元组2[-2] #取倒数第二个成员
元组 = 元组2[:1] #截取第二个成员后面的所有成员

#更多方法:https://www.runoob.com/python/python-tuples.html

列表-list (能灵活操作,类似数组)

列表1 = [1, 2, 3, 4, 5 ]
列表2 = ['a', 10, [1,2], {"id":"1"}]
列表3 = list((1,2,3,4))
列表4 = tuple("生成列表") #['生','成','列','表']自动逐字分割

#取值,第一个成员的索引从0开始
成员1 = 列表1[0]
成员2 = 列表1[1]
成员 = 列表1[1:3]#索引是从0开始的,所以这里是取第二个跟第三个的值[10, [1,2]]

列表1[0] = 100 #修改第一个成员值

列表1 = [] #覆盖成空列表

列表1.append("成员1") #加入成员

成员 = 列表1[-2] #取倒数第二个成员
列表  [:1] #截取第二个成员后面的所有成员

del 列表1[0] #删除第一个成员
del 列表1 #删除整个列表

列表1.count(1) #统计 1 在列表里出现的次数
列表1.reverse() #列表倒序

#更多方法:https://www.runoob.com/python/python-lists.html

集合-set (不存在重复的序列)

集合 = set([1,2,3,"a",1])
#集合={1,2,3,"a"},重复的成员会被过滤掉
#集合可以直接传入元组,列表,字典处理,字典默认处理的是字典的索引


a = {"1":10,1:"A",5:"55"}
集合 = set(a)
集合 = set(a.keys())
#集合={1, '1', 5},默认是集合字典的索引所以上面两种是一样的

a = {"1":10,1:"A",5:"55"}
集合 = set(a)
集合 = set(a.values())
#集合={'55', 10, 'A'},集合字典的值



集合 = set([1,2,3,4])
集合.add(4)
集合.add(5)
#集合={1, 2, 3, 4, 5}
#给集合里添加值,如果该值已存在则会被过滤掉



#集合是一个无序不重复元素集,也就是不会有重复成员的数组
#但无法通过索引取值,可以通过for循环或者转为元组,列表取值
集合 = set([1,2,3,4]) #集合[0] 这样直接取值会报错
列表 = list(集合) #列表[0] 可以正常取值
元组 = tuple(集合) #元组[0] 可以正常取值

#更多方法:https://www.cnblogs.com/cyx-12/p/9234285.html

字典-dict (可存储任意类型对象)

#字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

字典1 = {"a":1,"b":2,"c":True}
字典2 = dict([(1,10),("key","value")])#列表转为字典
#字典2 = {1: 10, 'key': 'value'}

字典3 = {'a': 1, 'b': 2, 'b': '3'}
#字典3['b']=3, 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

#字典3['键(索引)'] 
#字典取值用的不是0,1,2那些ID,而是你自己在里面定义的键(索引),如果传入的键不存在则会报错

字典3['d'] = 99
#新增,修改键值,如果字典里不存在d这个键则会新增该键值,如果存在则会修改d的值为99

del 字典3['d'] #删除键是'd'的条目
字典3.clear() #清空字典所有条目
del 字典3 #删除字典

#更多方法:https://www.runoob.com/python/python-dictionary.html

9.循环

range() 返回的是一个可迭代对象（类型是对象），而不是列表类型

range(10) 生成0-9, 10个数字,从0开始

range(4,9) 生成4-8, 5个数字,4是初始数,到9停止

range(1,10,2) 生成1 3 5 7 9,2是每次递增的数,从1开始到10停止,每次递增2

for x in range(10):
    print(x)

#输出结果：0 1 2 3 4 5 6 7 8 9
# x 是接收每次循环的变量,自己可以随便定义个变量
#等同  计次循环首(10,x) 不过这里是从0开始,Python里的列表,元组等序列都是从0开始

for循环不单单用来计次循环,他可以循环对象,列表,元组,字典,文本等,下面是部分循环示例

文本 = "这是一段文本"
for x in 文本:
    print(x)

#输出结果：这 是 一 段 文 本
#类似逐字分割

列表 = [1,"a",True,(1,"元组")]
for x in 列表:
    print(x)

#输出结果：1 "a" True (1,"元组")

字典 = {"a":10,"x":"python",5:[1,2,3],"z":{1:"字典"}}

#这里循环 字典 跟 字典.keys() 是一样的
for x in 字典:    #循环字典的索引,等同for x in 字典.keys():
    print(x)    #默认输出字典的索引,依次输出结果：a x 5 z
    print(字典[x])    #输出字典对应的值,依次输出结果：10 python [1,2,3] {1: '字典'}


for x in 字典.values():#循环字典的值
    print(x)

#输出结果：10 python [1,2,3] {1: '字典'}

for i in [1,2,3,4]:
    print(i)
else:
    print(i,'我是else输出的结果')

#输出结果：1 2 3 4 4我是else输出的结果

for i in [1,2,3,4]:
    if i>2:
        print(i)
        break
else:
    print(i, '我是else')

#输出结果：3
#else会在for全部循环完时执行,如果循环中跳出则不会执行

判断循环

x = 0
while x < 10:#当x >= 10 条件则不成立,就会停止循环继续执行下一步的代码
    x += 1
    print(x)

#输出结果：1 2 3 4 5 6 7 8 9 10
#while 后面跟着的是循环条件,条件成立就会执行里面的循环,类似判断循环首


while True:
    print("死循环")
#条件直接设置为True就会变成死循环

10.判断

#单独判断
if 判断条件：
    执行语句……

#示例
a = 0
if a == 0:#在python里比较必须用 ==  单个等于号是赋值的意思
    a = 1
print(a)

#分支处理
if 判断条件：
    执行语句……
else：
    执行语句……

#示例
身高 = 175
个子 = ""
if 身高 >= 175：
    个子 = "算高的"
else：
    个子 = "还算好"

#多分支判断
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

#示例
省份 = "广东"
省会 = ""
if 省份 == "广东":
    省会 = "广州"
elif 省份 == "广西":
    省会 = "南宁"
elif 省份 == "福建":
    省会 = "福州"
else:
    "算了不继续判断了"

#多条件判断, and(且) or(或)
#示例
a,b = 1,1 #等同a=1 b=1
if a > 0 and b > 0:
    print("条件成立")    #a跟b都大于0,条件是成立的
else:
    print("条件不成立")


if a > 10 or b > 0:
    print("条件成立")    #a虽然没大于10,不过b大于0,有一个条件成立就能进来执行
else:
    print("条件不成立")

#if判断的条件只要为True(真),就能进入执行, 任何非0和非空（null）值为true，0 或者 null为false 

#类似
if a != "":
if a != 0:
if a != []:
···
#都可以直接简写成
if a:
    print("条件为True")
else:
    print("条件为False")

11.类(class)

#简单的创建调用一个类

class 类名:    #用class创建一个类
    def a(self):    #类里面写方法 a
        return "1"

    def b(self,参数1): #类里面写方法 a
        return 参数1

类 = 类名() #实例化一个类
print(类.a()) #调用a 方法,输出结果:1
print(类.b(2))#调用b 方法，并给参数1传值2,输出结果:2

#self是一个形式参数,通常类里面的方法第一个参数都要带上,但调用的时候不需要传
#类 = 类名() #此时self等于 类
#类1 = 类名() #此时self等于 类1

#不带self

class 类名:
    def a():    #类里面写方法 a,不带self参数
        return "1"

print(类名.a()) #直接调用类名的a方法,#输出结果:1

#如果不带self则需要在不实例化的情况下才能直接调用,不带self的实例化后无法调用

#初始化,退出

class 类名:
    def __init__(self): #这是类里面自带的方法,这个类被实例化的时候会自动调用
        print("初始化")

    def __del__(self): #这是类里面自带的方法,这个类将要退出的时候会自动调用
        print("将要退出")

    def a(self):
        print("调用了a方法")

#传参,属性
class 类名:
    def __init__(self, id, name): #初始化这里可以接收参数,在实例化的时候传入
        self.编号 = id
        self.名称 = name
        self.文本 = "这是文本" #初始化时给类里面自定义声明个变量

    def 获取信息(self):
        return self.编号,self.名称,self.文本 #调用输出类里面定义的变量

类 = 类名(1,"管理员") #传入参数
print(类.获取信息()) #输出结果:(1, '管理员', '这是文本')

#公开跟私有属性
class 类名:
    def __init__(self, id, name):
        self.编号 = id
        self.名称 = name
        self.文本 = "这是文本" #普通的公开属性
        self.__匿名变量 = "匿名变量" #私有属性

    def __获取信息(self): #私有方法
        return self.编号, self.名称, self.文本  # 调用输出类里面定义的变量

类 = 类名(1, "管理员")  # 传入参数
print(类.文本) # 正常获取类里面的属性值
print(类._类名__获取信息())  # 调用私有方法
print(类._类名__匿名变量) # 调用私有属性

#在类的变量跟方法名前面加上双下划线 __ ,即定义为私有属性,方法
#私有属性方法在外面实例化之后不会显示,也不能直接调用
#不过Python的类里没有完全私有的方法,还是可以通过 "类._类名__匿名变量" 这种格式调用到私有属性方法

#调用
class 类名:
    def __init__(self, id, name):  # 这是类里面自带的方法,这个类被实例化的时候会自动调用
        self.编号 = id
        self.名称 = name

    def 获取编号(self):
        return self.编号

    def 返回信息(self):
        编号 = self.获取编号() #调用当前类里面的方法也要带上self
        return 编号

类 = 类名(1,"管理员")
print(类.返回信息()) #输出结果:1

#继承
class a类: #正常创建
    def a(self):
        return "这是a"

class b类(a类): #创建b类,并继承a类的所有方法,这里可以同时继承多个类
    def b(self):
        return "这是b"

类 = b类() #实例化 b类
print(类.a()) #输出结果:这是a
print(类.b()) #输出结果:这是b
#因为b类创建的时候继承了a类,所以实例化b类之后也能调用a类里的方法

#继承,重写方法
class a类:
    def a(self):
        return "这是a"

class b类(a类): 
    def b(self):
        return "这是b"

    def a(self): #重写a方法
        return "重写后的a"

类 = b类()
print(类.a()) #因为被重写,所以输出新的内容:重写后的a
print(类.b()) #输出结果:这是b

#继承后如果对继承过来的某些方法需要改动,只需要在类里面重新新建个名字一样的方法即可覆盖

#除了__init__(初始化) __del__(将要退出)的内置方法,类里面还有很多其他内置方法
#类的专有方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方

#更多资料参考:https://www.runoob.com/python3/python3-class.html

12.装饰器

def 某装饰函数(fun):         #装饰器函数,要用一个参数接收函数对象
    def 某参数(参数):        #里面在新建个函数接收那个函数的参数,有几个参数就跟着填几个
        if 参数 == 0:         #这个函数里面就对接收的函数跟参数做处理了
            return "这是0"     #如果传入的参数是0就直接返回这个，不执行装饰器下面的函数
        else:
            return fun(参数)  #如果不做处理可以这样返回原来的内容，装饰器下面的函数会继续正常执行，fun是上面接收的函数对象
    return 某参数              #最下面这里固定要放这个返回 return xxx，

@某装饰函数        #使用装饰器  @ + 装饰函数名
def 函数(x):
    return x

print(函数(0))
#输出结果：这是0   
#如果正常调用 函数(0) 他返回的是0，但是这里使用了装饰器，会先使用装饰器处理

#使用示例
def 验证(fun):
    def 某参数(参数):
        if 参数 == 0:#如果传入的参数为0则表示有权限执行
            return fun(参数)
        else:
            return "无权限"
    return 某参数

@验证
def 获取密码(x):
    return "有权限获取密码"

@验证
def 获取资料(x):
    return "有权限获取资料"

@验证
def 全部删除(x):
    return "有权限删除"

print("获取密码:" + 获取密码(0))
print("获取资料:" + 获取资料(1))#传入1 装饰器里判断没权限不会执行该函数会直接返回 无权限
print("全部删除:" + 全部删除(0))

#输出结果
"""
获取密码:有权限获取密码
获取资料:无权限
全部删除:有权限删除
"""

13.异常处理

Python程序运行时如果执行或请求出错会直接报错停止,需要用try来捕获是否处理

a = 10
print(a)
a += "0"
print(a)
#调试输出:10
#这里调试出10之后程序就会停止,因为a是整数型不能直接跟文本相加

a = 10
print(a)
try:
    a += "0"
except:
    pass
print(a)
#调试输出:10 10
#将可能出错的代码放在try里,出错时就会跳到except里,这里用了pass填充也就是出错时不做处理,所以正常输出两次10

#异常捕获处理的大致流程
#1
try:
    #<语句>
    #正常操作
except:
    #<语句>
    #发生异常，执行这块代码
else:
    #<语句>
    #如果没有异常执行这块代码


#2
try:
    #<语句>
    #正常操作
finally:
    #<语句>    #退出try时总会执行


#3

import traceback
try:
    pass
except:
    print(traceback.format_exc())
#导入traceback模块,这里报错的时候会调试输出完整的报错提示

try:
    pass
except Exception as erro: #except可以填写需要捕获的异常类型,用于针对指定错误类型做专门处理
    print(erro)
#Exception是拦截常规错误,这里只会调试输出报错时提示的TypeError

#更多方法:https://www.runoob.com/python/python-exceptions.html

异常名称	描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python 语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告