python

python视频地址

1.输出函数print
直接输出
输出到文件中：先打开文件（没有则创建），print，关闭文件
    fp = open('D:\\桌面\\text.txt','a+')
    print('aaaa')
    fp.close()
不换行输出：多个内容
    print('a','b')
2.转义字符
\n换行，\t制表符（含4格），\r光标回到本行开头，\b光标退回一格，\\反斜杠，\'单引号，\"双引号
3.标识符、保留字、变量
标识符：变量、类，函数，模块，对象的名字等，区分大小写
保留字：固定的
变量：类似于带标签的盒子，由标识（对象所存储的内存地址，id()）、类型（type()）、值组成。
    不同的值在不同的空间，为同一个变量多次赋值后，变量会指向新的空间
4.数据类型、数据类型转换
整型
浮点型
布尔型：可变整型print(False+1)=>1
字符型：可用单引号、双引号、三引号（逗号隔开，可换行打印）。
数据类型转换：str()、int()、float()
5.输入函数input
    x=input("输入一个数:")=>x=2
    print(type(x)) =>str
6.算术、赋值、比较、布尔、位和优先级
算术运算符：//取整，%取余，**幂运算
赋值运算符：=，+=，-=，%=等，链式=
比较运算符：结果bool，is、is not比较对象的id
布尔运算符：and、or、not、in与not in
    print(True and False)=>False
    print(True or False)=>True
    print(not True)=>False
    print('s' in 'whs')=>True
位运算符：位或|（对应位数都是0，结果对应0，否则为1）、位与&（对应位数都是1，结果对应1，否则为0）、左移位<<（高位舍弃，低位补0）、右移位>>（低位舍弃，高位补0）
    print(5&4)#5:101 4:100=>100=>4
    print(5|4)#=>101=>5
运算符优先级：算术>位>比较>布尔>=
7.程序的组织结构、pass、range、break、continue
顺序结构
对象的布尔值：python的一切都是对象，所有对象都有一个布尔值bool()，数值为0、空的都是布尔值为False
选择结构：单分支、双分支、多分支、嵌套if
单分支：if
双分支：if else
多分支：if elif ... elif else
嵌套if：if：if else 
pass语句：什么都不做，只是占位符
range()：返回迭代器对象
循环结构：while、for...in
while：判断N+1次，True时执行N次
for  自定义变量或_  in 可迭代对象：in从中取值，又称为遍历
break：结束循环结构
continue：结束当前循环，直接进入下一个整体循环的开始
    a=0
    while a<5:
            if a<3:
                print('good')
                a=a+3
                continue
        else:
                print(a)
        a+=1     
=>good  3  4
else：if、while、for
if：条件不成立，执行else
while、for：没有碰到break，执行else
a=0
    while a<5:
        if a<3:
                print('good')
                a=a+3
                continue
        else:
                print(a)
            break
        a+=1
    else:
            print("bad")
=>good 3
二重循环中的break和continue：
for a in range(5):
    for i in range(1,6):
        if(i%2==0):
            break
        print(i)
=>1 1 1 1 1
for a in range(2):
    for i in range(1,3):
        if(i%2==0):
            continue
        i+=4
        print(i)
=>5 5

************************************************************************************************
8.列表[]
8.1列表[]：相当于c中的数组，按顺序存储，索引对应唯一元素，根据需要动态分配和回收内存 
8.2列表的创建：
    1.使用[]：lis=['ab',2]
    2.使用list()函数：lis=list(['ab',2])
    3.列表生成式
        lis=[L for L in range(1,4)]
        =>[1, 2, 3]
8.3根据元素获得索引：list.index(元素)，多个元素只返回第一个
    lis=['ab',2,3,4]
    print(lis.index('ab',0,2))
    print(lis.index('ab',1,2))
=>0
=>'ab' is not in list
8.4根据索引获得元素：list[]
    lis=['ab',2,3,4]
    print(lis[3])
    print(lis[::-1])
=>4
=>[4, 3, 2, 'ab']
8.5列表查询：是否存在（返回bool）和遍历
是否存在：元素 in 列表名
遍历：for 迭代变量 in 列表名
    lis=['ab',2,3,4]
    print(2 in lis)
    for _ in lis:
            print(_)
8.6列表添加：list.append()，list.extend()，list.insert()，切片
list.append(元素)：队末添加一个元素
    lis=['ab',2,3,4]
    lis.append('ac')
    print(lis)
list.extend(元素)：队末添加至少一个元素
    lis=['ab',2,3,4]
    lis.extend(lis2)
list.insert(位置，元素)：任意位置添加元素
    lis=['ab',2,3,4]
    lis.insert(0,1)
    print(lis[::])
=>[1, 'ab', 2, 3, 4]
切片：
    lis=['ab',2,3,4]
    lis2=[1,2]
    lis[1:]=lis2
    print(lis)
=>['ab', 1, 2]
8.7列表删除：list.remove()、list.pop()、list.clear()、del、切片
list.remove(元素)：一次删除一个元素
list.pop(索引)：不填索引值，则删除最后一个
list.clear()：清空列别
del list：将list对象删除
    name 'list' is not defined
8.8列表排序：list.sort()，sorted()
list.sort()：默认升序，参数reverse=True改降序
    lis2.sort()
sorted(列表)：生成新列表，不改变原列表，默认升序
    lis1=sorted(lis)

9.字典{}
9.1字典{}：可变无序（第二个放进来的不一定在第二个位置）的序列，键值对存储。根据key寻找value的位置。键唯一。
9.2字典的创建：
    1.{}：dic={}、dic={'wh':2}
    2.dict()：dic=dict({'wh':2})
    3.字典生成式：zip(键列表，值列表)
        name=['w','s','c']
        price=[2,3,4]
        d={n:p for n,p in zip(name,price)}
=>{'w': 2, 's': 3, 'c': 4}
        d={n.upper():p for n,p in zip(name,price)}
=>{'W': 2, 'S': 3, 'C': 4}
9.3元素取值
    1.[]：dict['键']
    2.dict.get('键')
        dic2.get('h',99)：h存在则输出对应值，不存在就输出99
9.4字典操作：判断、删除、增加
判断：键 in、not in dict
删除：dict.clear()清空、del dict['键']删除指定键值对
增加：dict['键']=值
9.5字典试图
dict.keys()：获取所有key
dict.values()：获取所有value
dict.items()：获取所有键值对
9.6字典的遍历
    for i in dic2:
            print(i)=>键
            print(dic2[i])=>值
            print(dic2.get(i))=>值

10.元组()
10.1元组()：不可变的序列（没有增删改），只有一个元素需要一个逗号
10.2元组的创建：
    1.()
    2.t=tuple((元素，))
    3.空元组：t=tuple()、t=()
10.3元组元素可以有列表，列表是可变的：
    t=tuple((1,3,[2,3]))
    t[2].append(100)
    print(t)
=>(1, 3, [2, 3, 100])
10.4元组的遍历：for item in tuple、tuple[index]

11集合{}
11.1集合{}：可变无序，是没有value的字典，不允许重复
11.2创建
    1.s={}
    2.s=set(range()，列表，元组，字符串)：重复的自动去掉
    3.空集合：s=set()
    4.生成式：{L for L in range(10)}         
11.3判断、增加、删除
增加：s.add(元素)、s.update(多元素、列表集合原则)
删除：s.remove(指定元素)没有抛出异常、s.discard(指定元素)没有不抛出异常、s.pop()一次删除任意一个元素、s.clear()
11.4集合关系：相等
相等=：只要内容元素相等，顺序不一样也相等
子集.issubset(父集)：返回bool
超集.issuperset(子集)：返回bool
是否有交集isjdisjoint：s1.isjdisjoint(s2)
11.5集合的数学操作
交集：s1.intersection(s2)、 s1&s2
并集：s1.union(s2)、s1|s2
差集：s1.difference(s2)、s1-s2
对称差集(并集-交集)：s1.symmetric_difference(s2)、s1^s2

12.字符串
12.1字符串：不可变的字符序列，可单引号、双引号、三引号。
驻留机制：相同的字符串只开辟一个内存空间。符合情况：字符串的长度为0或1、符合标识符的、只在编译时驻留而非运行时、[-5,256]之间的整数。
12.2字符串查找：str.index()、str.rindex()、str.find()、str.rfind()
str.index(‘字符串’)：字符串第一次出现的第一个字符的位置，没有则输出异常
str.rindex(‘字符串’)：字符串最后一次出现的第一个字符的位置，没有则输出异常
str.find(‘字符串’)：字符串第一次出现的第一个字符的位置，没有则输出-1
str.rfind(‘字符串’)：字符串第一次出现的第一个字符的位置，没有则输出-1
12.3字符串大小写转换：str.upper()、str.lower()、str.swapcase()、str.capitalize()、str.title()
str.upper()：转成大写，生成新对象。n=str.upper()
str.lower()：转成小写，生成新对象。
str.swapcase()：大小写转换，生成新对象。
str.capitalize()：第一个字符大写，其余小写，生成新对象。
str.title()：每个单词的第一个字符大写，其余字符小写，生成新对象。
12.4字符串对齐：str.center()、str.ljust()、str.rjust()、str.zfill()
str.center(生成字符串的宽度，填充字符默认空格)：居中。宽度小于字符串，则返回字符串。
str.ljust(生成字符串的宽度，填充字符默认空格)：左对齐。宽度小于字符串，则返回字符串。
str.rjust(生成字符串的宽度，填充字符默认空格)：右对齐。宽度小于字符串，则返回字符串。
str.zfill(生成字符串的宽度)：右对齐，左边用0填充。宽度小于字符串，则返回字符串。
12.5字符串劈分：str.split()、str.rsplit()
str.split(默认空格劈分，sep选择劈分字符，maxsplit指定最大劈分次数)：左边开始。返回列表。经过maxsplit，剩下的单独做一部分。
str.rsplit(默认空格劈分，sep选择劈分字符，maxsplit指定最大劈分次数)：右边开始。返回列表。经过maxsplit，剩下的单独做一部分。
12.6字符串操作：str.isidentifier()、str.space()、str.isalpha()、str.decimal()、str.isnumeric()、str.isalnum()
str.isidentifier()：判断字符串是不是合法的标识符
str.space()：判断字符串是否全部由空白字符组成（回车、换行、水平制表符）
str.isalpha()：判断字符串是否全部由字母组成
str.decimal()：判断字符串是否全部由十进制的数字组成
str.isnumeric()：判断字符串是否全部由数字组成
str.isalnum()：判断字符串是否全部由数字和字母组成
12.7字符串替换和合并：str.replace()、''.joint()
str.replace(原字符，替换字符，替换次数)：
'连接符'.joint()：将列表或元组中的字符串合并成一个字符串
    a=['ahD','DDD,ddd']
    print('*'.join(a))
=>ahD*DDD,ddd
12.8字符串的比较
==：比较value
is：比较id
12.9格式化字符串：.format()
‘格式化字符串’%(实际值)：%作占位符
‘格式化字符串’.format(实际值)：{}作占位符。‘{宽度：.精度}’.format(数字)
f-string：
‘%宽度.精度’%数字：
    name='张三'
    age=22
    print('你叫%s,今年%d岁'%(name,age))
    print('你叫{0},今年{1}岁'.format(name,age))
    print(f'你叫{name},今年{age}岁')
=>你叫张三,今年22岁
12.10字符串编码转换
编码：将字符串转换为二进制byte。str.encode(encoding=‘’)
解码：将二进制转换成字符串。byte.decode()

************************************************************************************************
13.函数
13.1函数：执行某个任务和完成某个功能的代码
13.2函数的创建：
    def 函数名(函数参数)：
        函数体
        [return ×××]
个数可变的位置参数：def 函数名(*函数参数)，输入参数可变。结果为元组。只能有一个。
    def aa(*a):
        print(a[1])
    # aa(20)
    aa(20,100)
    print(12,13,14)
=>100         12 13 14
个数可变的关键字形参：def 函数名(**函数参数)，输入参数可变。结果为一个字典。只能有一个。
    def bb(**b):
            print(b)
    bb(a=20,b=100)
=>{'a': 20, 'b': 100}
13.3函数的返回值：
多个返回值，结果为元组：
    def aaa(num):
            old=[]
            new=[]
            for i in range(num):
                    if i%2:
                            old.append(i)
                    else:
                            new.append(i)        
            return old,new
    c=aaa(6)
    print(c)
=>([1, 3, 5], [0, 2, 4])
13.4参数代码
    def fun(a, b, c):
            print('a:', a)
            print('b:', b)
            print('c:', c)

    list = [11, 22, 33]
    dict = {'a': 11, 'b': 22, 'c': 33}
    fun(11, 22, 33)  # 函数调用时的参数传递，称为位置实参=>a: 11 b: 22 c: 33
    fun(*list)  # 转换为位置实参传入=>a: 11 b: 22 c: 33
    fun(*dict)=>a: a b: b c: c
    fun(**dict)  # 关键字参数=>a: 11 b: 22 c: 33
13.5变量
局部变量：函数内定义并使用的变量。局部变量使用global声明，变全局变量。
全局变量：函数外定义的变量。

14.Bug
14.1python处理异常：try-except、try-except-else、try-except-else-finally
try-except：在异常出现时及时捕获，然后“消化”，使程序继续运行
    try：
        可能出现异常的代码
    except  异常类型：
        异常处理代码

    try:
                a=int(input("请输入第一个数:"))
                b=int(input("请输入第二个数:"))
                result=a/b
                print('结果为：',result)
    except ZeroDivisionError:
            print('对不起，除数不允许为0')
    except ValueError:
            print('对不起，只能为字符串')
    print('结束程序')
try-except-else：try中抛出异常，则执行except；try中没有抛出异常，则执行else块
try-except-else-finally：finally无论异常都执行，常用来释放try块中申请的资源
14.2常见异常类型： ZeroDivisionError、IndexError、KeyError、NameError、SyntaxError、ValueError
ZeroDivisionError：除零、取模零
IndexError：序列中没有此索引
KeyError：映射中没有这个键
NameError：未声明/初始化对象（没有属性）
SyntaxError：语法错误
ValueError：传入无效的参数
14.3traceback模块使用
    import traceback
    
    try:
            print(1/0)
    except:
            traceback.print_exc() #打印或读取堆栈的详细的异常信息
14.4调试：断点
断点：此处前面点一下得到小红点，运行到此处，暂时挂起，停止执行。可以按Debug，然后下一步。

************************************************************************************************
15.类与对象
面向过程：比较简单，线性思维。比如吃饭，第一先做饭，第二盛饭，第三张嘴吃饭。
面向对象：更复杂，线性思维无法解决。比如吃饭，直接美团找饭点外卖，不需要思考如何做怎么做。
类是统称，如整型等数据类型。
对象是个例，也可称为实例，如11是int类下的个例。
类：
创建类：定义时首字母要大写。
类的组成：类属性、实例方法、静态方法、类方法
    类属性：直接写在类中方法外的变量，被该类的所有对象共享。使用‘类名.类属性名字’直接访问    
    实例方法：类内定义的函数叫方法
    静态方法：由@staticmethod修饰的，不能写self。使用‘类名.方法’直接访问    
    类方法：由@classmethod修饰的，带cls。使用‘类名.方法’直接访问
    这些都是类对象
对象：
创建对象：又称为类的实例化。
    实例名=类名()
动态绑定属性和方法：可以在创建对象后，进行
    def www():
        print(‘zzz’)
    uu=Fun('张三')    
    uu.gender='女'#动态绑定性别
    uu.www=www#动态绑定方法
    uu.www()    
代码：
class Fun:
    a = '11'  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性，此处进行赋值。属于该类中所有方法，都可以用

    # 实例方法
    def fun(self):  # self，传入一个Fun类型的对象
        print(self.name+Fun.a)

    # 静态方法
    @staticmethod
    def am():
        print('b')

    # 类方法
    @classmethod
    def cm(cls):
        print('c')

# 创建对象
# 实例对象
f = Fun('张三')#张三11
f.fun()#张三11
Fun.fun(f)#b
f.am()#b
Fun.am()#张三
print(f.name)#11
print(Fun.a)#zzz

16.面向对象
16.1三大特征：封装、继承、多态。（适用所有语言）
封装：属性和方法（数据与行为）封装到类对象内，在放大内对属性进行操作。在类对象外部进行调用。比如ATM取款机，我们只关注使用它取钱，不关注也看不到里面如何实现。
    私有：不希望在类对象外部被访问，前面加两个‘_’。self.__age。在类外部可以通过实例对象._类名.__age访问。
继承：默认继承object，可继承多个父类，必须在子类构造函数中调用父类的构造函数
    class 子类类名（父类1，父类2...）:
class Fun(object):
    a = '11'  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性，此处进行赋值。属于该类中所有方法，都可以用

    # 实例方法
    def fun(self):  # self，传入一个Fun类型的对象
        print(self.name+Fun.a)

    # 静态方法
    @staticmethod
    def am():
        print('b')

    # 类方法
    @classmethod
    def cm(cls):
        print('c')

class Na(Fun):
    def __init__(self,name,age):
        super(Na, self).__init__(name)
        self.age=age

na=Na('张三',20)
na.fun()#张三11
多态：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用
    静态语言：实现多态需要3个必要条件，即继承、方法重写、父类引用指向子类对象。如java
    动态语言：实现多态，只要有行为，不管对象类型。如python
class Animal:
    def eat(self):
        print('动物要吃东西')

class Dog(Animal):
    def eat(self):
        print('狗吃骨头')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person:
    def eat(self):
        print('人吃杂粮')

def fun(obj):
    obj.eat()

fun(Animal())=>动物要吃东西
fun(Dog())=>动物要吃东西
fun(Cat())=>猫吃鱼
fun(Person())=>人吃杂粮

16.2方法重写：对父类的某个方法进行重写。通过super().方法名()
    def fun(self):
        super(Na, self).fun()
        print('huave fun')
    若A，B，B继承A，C想继承A和B时，可以直接继承B。当B重写A中的方法时，C可能无法分清A和B，所以只写B。
    class Bb(Na):
            def __init__(self,name,age,sex):
                    super(Bb, self).__init__(name,age)
                    self.sex=sex

16.3object：是所有类的父类。
内置dir()可查看指定对象所有属性
_str_（）方法：返回一个对于“对象的描述”，直接打印实例对象返回_main_类名 obeject at id，对其重写后返回重写打印内容

16.4特殊方法和特殊属性
特殊属性：__dict__，获得类对象或实例对象所绑定的所有属性和方法的字典
    实例.__dict__：输出实例的属性字典
    类名.__dict__：输出类的属性字典
    实例.__class__：输出对象所属的类
    类名.__bases__：该类的父类类型的元素
    类名.__base__：输出该类继承的第一个写上去的父类的元素
    类名.__mro__：输出类的层次结构
    类名.__subclasses__()：输出该类的子类的列表
特殊方法：
__len__()：通过重写，使其可以自定义类型
    def len（self）：
        return len（self.name）
__add__()：通过重写，可使自定义对象具有‘+’功能 
        def __add__(self，other)：
            return self.name+other.name
        
        str1.__add__(str2)
        print(str1+str2)

__new__()：用于创建对象
__init__()：对创建的对象进行初始化
    class Person(object):
            def __new__(cls, *args, **kwargs):
                    print('__new__被调用执行了{0}'.format(id(cls)))
                    obj=super().__new__(cls)
                    print('创建的对象id为{0}'.format(id(obj)))
                    return obj

        def __init__(self,name,age):
                print('init调用了，self的id为{0}'.format(id(self)))
                self.name=name
                self.age=age

    print('object这个类对象的id：{0}'.format(id(object)))
    print('Person类对象的id：{0}'.format(id(Person)))

    pl=Person('张三',20)
    print('pl这个对象的实例对象的id:{0}'.format(id(pl)))
=>
    object这个类对象的id：140714425219888
    Person类对象的id：2012661974784
    __new__被调用执行了2012661974784
    创建的对象id为2012680552112
    init调用了，self的id为2012680552112
    pl这个对象的实例对象的id:2012680552112

16.5浅拷贝和深拷贝
赋值：指向同一个对象
浅拷贝：python拷贝一般都是浅拷贝，拷贝时拷贝源对象，对象包含的子对象内容不拷贝，源对象与拷贝对象会引用同一个子对象。类似于快捷方式
    import copy
    computer2=copy.copy(computer1)
    computer2的id与computer1的id不同，但是子对象的id一样
深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
    computer2=copy.deepcopy(computer1)

************************************************************************************************
17.模块
17.1模块：一个.py的文件就是一个模块
    导入模块：
        1.import 模块名称 [as 别名]
        2.from 模块 import 函数/变量/类
17.2包：一个分层次的目录结构，将多个功能相近的模块组织在一起。包含__init__.py文件的目录称为包，目录通常不包含该文件。
    导入包：
        1.import 包.模块
        2.from 包 import 模块
        3.from 包.模块 import 类

17.3主程序运行：
cal.py：
    def add(a,b):
        return a+b
    if __name__ == '__main__':
        print(add(10,20))=>30
demo.py：
    import cal
    print(cal.add(100,200))=>300
若没有：
cal.py：
    def add(a,b):
        return a+b
    print(add(10,20))=>30
demo.py：
    import cal
    print(cal.add(100,200))=>30  300
17.4常用内置函数库
sys：与python解释器及其环境操作相关的
time：与时间有关
os：提供访问操作系统服务功能
calendar：与日期相关
urllib：用于读取来自网上（服务器）的数据标准库
json：使用JSON序列化和反序列化对象
re：字符串正则表达式匹配和替换
math：算术运算相关
decimal：十进制运算
logging：记录事件、错误、警告、调试信息等日志信息
17.5文件的读写
读写俗称为IO操作
流程：python操作文件->打开或新建文件->读、写文件->关闭资源
          |----------------------- |
          |  |------------------ |    |
          |  |    |--------------|   |    |
          |  |    | python文件  |   |    |
          |  |    |--------------|   |    |
          |  |         解释器         |    |       
          |  |------------------ |    |
          |           OS                    |
          |------------------------|
                         |            操作
                         |------------------------>硬盘
读写操作：
file=open(filename[,mode,encoding])，需要关闭file.close()
    file：被创建文本对象
    mode：
        r：只读
        w：只写
        a：追加模式，存在则在末尾追加内容，不存在则创建
        b：二进制方式打开，不能单独使用，需rb，wb
        +：读写方式，不能单独使用，如a+
     
with open() as file:  不需要关闭，无论运行正常与否，都会正确关闭。
    file.write('a')
os模块：
os.listdir(path)：当前目录下的文件名
os.path模块：
    exists(path)：判断文件是否存在
    isdirpath()：是否为路径
    join(path,name)：连接目录页与目录或文件
    splitext()：分离文件名和扩展名