2021-10-06

python学习笔记

                                                              基础

一.类型转换

      int() ：转换时，可以把整数字符串、布尔类型、float转换为整数，eg：print(int(’128‘))，输出结果为128。但小数字符串或文字字符串就不可以类型转换，eg：int('我是谁')，会报错。

二.input()

三.赋值

      支持链式赋值 eg：a=b=c=3，且a、b、c标识相同，即都指向同一内存单元

      解包赋值 eg：a,b,c=20,30,40 

      交换两个变量的值：eg：a,b=b,a

四.运算符

     1.算数运算符

        整除运算// eg：print(11//5)，输出结果是2。注意：若是一正一负相整除，则向下取整。eg：print(9/-4)或print(-9/4)，输出结果都为-3

      幂运算** eg：print(2**3)，表示2的3次方，输出结果是8

      取余运算% 注意：一正一负时，结果是余数=被除数-除数*商 eg：9%(-4)=-3，过程为9-(-4)*(-3)=9-12=-3。eg：(-9)%4=3，过程为-9-4*(-3)=-9+12=3

     2.比较

      ==比较两个变量的值

      is 比较两个变量的标识，若相同则为True。 eg1：a=10 b=10 print(a is b)，输出结果为True。eg2：lst1=[11,22,33,44]  lst2=[11,22,33,44] print(lst1 is lst2)，输出结果为False

      is not 比较两个变量的标识，若不相同则为True，相同则为False

      3.布尔运算符

        and，or，not， 

       in 此字符是否在字符串里面 eg:s='helloworld'       print('w' in s)       print('k' in s)  输出结果为True和False                 

       not in 同理             

    4.位运算符

       & 按位与，同为1时为1，其他为0

       |  按位或，同为0时为0，其他为1

       << 左移位运算符，高位溢出舍去，低位补0

       >> 右移位运算符，低位溢出截断，高位补0

注意：运算符优先级：算数运算符(加减乘除幂)>位运算符(&)>比较运算符(>=)>布尔运算>赋值运算符

                                                               流程控制

一.条件语句

二.pass语句

      什么都不做，只是一个占位符，用到需要些语句的地方，在没想到代码怎么写时，可以用来搭建语法结构。

三.range()函数

       用于生成一个整数序列 

       range(stop):创建一个(0,stop)的整数序列，步长为1,默认从0开始

      range(start,stop);步长为1，从start开始，到stop结束(不包含stop)，即取左不取右

      range(start,stop,step)

      可以用in或者not in判断整数序列中师傅存在整数

四.while循环

五.for in循环

        eg：for item in 'python'  从python字符串中依次选中字母赋给item

               for i in range(4)；i从0到3

               for _ in range(4):效果同上

六.break和continue

        break：结束循环结构

       continue：用于结束当前循环，进入下一次循环

七.else也可用于for和while循环

 八.列表

         列表存储空间示意图

        

        列表的创建：使用中括号  eg:lst=['hello','world',98]

                           调用内置函数list   eg:lst=list(['hello','world',98])

        注意：可以任意数据类型混存，且可以动态分配和回收内存，不用预先分配，不用担心多也不用担心不够用

列表索引;

                

         index()：获取列表中指定元素的索引 1.若列表中存在N个相同元素，则只返回第一个元素的索引  2.若查询的元素不在列表中，则会弹出ValueError  3.还可以在指定的start和stop之间查找 eg:lst.index(’hello‘,1,3) 查找时不包括3

         获取列表中的多个元素：切片操作。列表名[start:stop:step]

   eg:   结果：

          列表遍历：for 迭代变量 in 列表名                           eg：for item in lst

          列表中添加变量:append()：在列表末尾添加一个元素    eg1：lst.append(100)

                                                       eg2：lst.append(lst2) 将lst2整个列表作为一个元素添加进lst中，结果为

                                   extend(),在列表末尾至少添加一个元素  eg：lst.extend(lst2)，结果为         

                                   insert()：在列表的任意位置添加一个元素 eg：lst.insert(1,'hello')

                                   切片：eg：lst[1:]=lst3    把lst从索引为1的位置之后的元素全部切掉，然后换成lst3

          列表删除操作：

                                    

                eg：lst.remove(30)   移除列表lst中为30的元素

                       lst.pop(2)   移除索引为2的元素

                       切片：new_lst=lst[1:3]     原列表lst不变，产生一个新列表new_lst，内容为原列表的索引为1，2的元素。。。。。。。若要不产生新的列表，仅删除列表中的内容，则 lst[1:3]=[]

          列表修改操作：eg：lst[1:3]=[100,200,300,400,500]    把原lst中索引1，2切片掉，换成100,200,300,400,500

          列表的排序操作：sort() 默认升序   eg：lst.sort()  结果为lst将重新进行升序排序，原列表改变

                                       sort(reverse=True)  降序排序

                                       sorted()  eg1：new_lst=sorted(lst)  结果为原列表不变，new_lst为原列表的升序列表     eg2：new_lst=sorted(lst，reverse=True)

          列表生成式：eg：lst=[i*i for i in range(1,6) ]    结果为lst中存储了[1，4，9，16，25]

                                                                    字典

以键值对的方式存储数据，字典是一个无序的序列，即第一个放入字典的数据不一定存储在第一位，因为放入的位置是经过对键的hash函数得来的

scores={'张三':100,'李四':98,'王五'：45}

student=dict(name='jack',age=20)

字典元素的获取：scores[’张三‘]    若查找中不存在该key，则会报错KeyError

                             scores.get('张三')    若查找中不存在，则回返回None，eg1：                                                           print(scores.get('张三')) 则会输出None。eg2：print(scores.get('麻七'，99) ，                                 当指定键‘麻七’所对应的值不存在时则会输出默认值99

 字典的判断：eg：print('张三' in scores)

字典元素的删除：del scores['张三']   删除指定的键值对

                             scores.clear()   清空字典的元素

字典元素的新增：scores['jack']=90

字典元素的修改：scores['jack']=60

获取字典视图：

                       

                      eg：keys=scores.keys()    print(keys)   输出结果为dict_keys(['张三','李四','王五'])   可以用list(keys)转成列表

字典元素的遍历：

                         

 字典生成式;zip()打包操作：用于将可迭代的对象作为参数，将对象中对应的参数打包成一个元组，然后然会由这些元组组成的列表      eg：  

                     

      结果为：

                                                                元组

不可变序列：字符串、元组，没有增删改操作

可变序列：列表、字典，可以对序列执行增上操作，对象地址不发生更改

元组的生成：方式一：t=('python','world',98)      或者  t='python','world',98

           方式二：t1=tuple(('python','world',98))

           注意：若只包含一个元组的元素需要使用逗号和小括号     t=(10,)

元组的遍历：for item in t:

                                                              集合

是可变类型的序列，只存储键，所以集合中的元素不允许重复。集合中的元素是无序的

集合的生成：s={'python','hello',90}

                     s=set(range(6))      输出s结果为{0，1，2，3，4，5}

                     s2=set([1,2,3.4])    即把列表[1,2,3,4]转成集合

                     print(set('python'))   把字符串转成集合 输出结果为：{'n', 't', 'o', 'y', 'h', 'p'}

集合的操作：

 update()一次至少添加一个元素，里面可以添加集合、列表、元组（啥括号都可以给你拆了，放进集合里面）

pop():集合随机排序后删除第一个元素

集合之间的关系：两个集合是否相等用==或！=判断

                             一个集合是否是另一个集合的子集用issubset()判断

                             一个集合是否是另一个集合的超集用issuperset()判断

                             两个集合是否么有交集用isdisjoint()判断，若没有交集，则为True

集合的数学操作：求交集：s1.intersection(s2)   或者   s1 & s2   原集合不会发生变化

                             求并集：s1.union(s2)     或者  s1 | s2   原集合不会发生变化

                             求差集：s1.difference(s2)  或者  s1-s2    原集合不会发生变化     

                              求对称差集：s1.symmtric.difference(s2)   或者s1^ s2  

                                 

集合生成式：s={i*i for i in range(6)}    生成无序的

 区别：

                                                                          字符串 

字符串不可变。字符串的驻留机制：仅保留一份相同且不可变的字符串的方法，python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量。

                             

所以在需要进行字符串拼接时建议使用str类型的join方法，而非+

字符串的查询方法：

建议使用find()

字符串大小写转换：

eg：a=s.upper()   转换后将会产生新的字符串      即只要用了函数，就会开辟新空间。 

 字符串内容对齐操作：

字符串的劈分操作：

 eg：                                                                     结果是：

      

 字符串的判断：

eg：print(’张三1‘.isalpha)    打印结果为False

 字符串的其他操作：

eg:                                                                    输出结果为：

              

 ~字符串的比较操作：运算符：>,>=,<,<=,==,!=      比较的是各个字符的ASCII码，从两个字符串的第一个字母开始挨着挨着比较。 ord()可以得到字母的原始值，即ASCII码的值。

~字符串的切片操作：[start：stop：step]     注意：当步长为负数时，默认从字符串的最后一个元素开始，到字符串的第一个元素结束。  eg：s='hello'    print(s[::-1])   输出的结果为olleh

~格式化字符串：%或者{}做占位符      %s占位字符串，%i或%d占位整数，%f占位浮点数。eg：

                

%10d中的10表示宽度    %10.3f其中10表示宽度，3表示保留小数点后三位

print('{0:10.3f}'.format(3.1415926))   同理，其中10表示宽度，3表示保留小数点后三位

~字符串的编码转换：编码encode()和解码decode()    eg:

   结果是：

                                                                          函数

 ~函数的返回值：1.函数可以没有返回值    

                          2.函数可以有一个返回值，则直接返回类型，你是列表我就返回列表，你是整数                                 我就返回整数。

                         3.函数的返回值如果是多个，返回的结果为元组

 ~函数的参数定义：def fun(a,b=10)    b称为默认值参数

   个数可变的位置参数：无法确定传递的位置的实参个数     def fun(*args)：    该参数只能定义一个，结果为一个元组 eg：

   个数可变的关键字形参：无法确定传递的关键字实参的个数   def fun(**args)：   该参数只能有一个，结果为一个字典 eg：

  

注意：在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求个数可变的关键字形参放在个数可变的位置形参之前，即*放在**之前。eg：def fun(*args1,**args2):

将列表中的每个元素都转换为实参时，使用*。将字典中的每个键值对都转换为实参时，使用**

 eg：

结果：a=11  b=22  c=33 

位置实参传递和关键字实参传递：函数参数传递那，从*之后的参数，在函数调用时，只能采用关键字传递。

以下几种写法都是可以： 

 

 以上函数的参数总结：

 ~局部变量用global去申明就会变成全局变量

 p98-p104

                                                                           类和对象

 python中一切皆对象

静态方法：用@staticmethod修饰

 类方法：用@classmethod修饰

调用：对象名.方法名    或者     类名.方法名(类的对象)-------->实际就是方法定义处的self

类属性、类方法和静态方法：

 eg：

内存示意图：

 动态绑定属性和方法：python是动态语言，在创建对象后，可以动态地绑定属性和方法。只针对绑定的对象起作用，eg：

~ 封装：例如类中用了两个下划线__的属性，在类外则不可以使用  eg：

 ~ 继承：

   

 如果一个类没有继承任何类，默认继承object类。python支持多继承，定义子类时，必须在其构造函数中调用父类的构造函数。eg：

 ~ 方法重写：如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其(方法体)重新进行编写。子类重写后的方法可以通过super().xxx()调用父类中被重写的方法。eg： 

 

 ~ 多态：动态语言，使用时只关心你是否具有这个方法

特殊方法和特殊属性：__xx__()

也可以用  对象.__bases__ 查看对象所继承的类

s=stu1+stu2  与 s=stu1.__add__(stu2）效果相同  eg：此例中重写了add()函数，若不重写，则直接为两数相加

 __new__与__init__演示创建对象过程：（没太懂）

 类的浅拷贝与深拷贝：

浅拷贝：python拷贝一般都是浅拷贝。computer2=copy.copy(computer)操作时浅拷贝 浅拷贝只拷贝外壳，没有拷贝内容，内容还是用原来的那份。

 内存示意图（理解了就好，也不需要太看，留存此图是以防将来查看）

 深拷贝:使用copy模块的deepcopy函数  外壳和内容都重新拷贝一份。

                                                                          模块

 一个.py就是一个模块，模块里面可以有函数、类、语句。

 ~ 以主程序方式运行：

 ~ 包：包是一个分层次得目录结构，它将一组功能相近的的模块组织在一个目录下

           包与目录的区别：包包含__init__.py这个文件，而目录不包含此文件。

           import 包名.模块名 (as 别名)

          import  模块名 

          from 包名 import 模块名     （使用这种也可以导入函数、变量等。。）

 python中常用的内置模块：

 第三方模块的安装与使用：

                                                                   最后一章 

 ~ 编码格式：如果想改变编码格式使用#encoding=gbk

 ~ 文件的读写：open()创建文件对象

 ~ 常用的文件打开模式：

 eg：复制logo.png，取名为copylogo.png

 ~ 文件对象的一些常用方法：

~ with语句（上下文管理器）：可以自动关闭资源，不需要再写close()来手动关闭了  eg：

eg：此时使用with实现图片的复制只需要三步：

~ 目录操作：os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句执行结果通常与操作系统有关，在不同的操作系统下运行，得到的结果可能不一样。eg;

import os                                        
os.system('notepad.exe') 可以直接打开记事本      

还可以用os.startfile('路径')去打开可执行文件

~ os模块操作目录的相关函数：

~ os.path模块操作目录的相关函数：

 eg：打印出该目录下所有的py文件

 os还有一个walk函数，可以递归遍历当前目录以及当前目下的所有子目录。walk返回的是一个三元组（root，dirs，files）(路径，目录，文件）eg：

输出结果：

eg：

end。。。

结合此教学视频学习的python，视频链接如下。花了2万多买的Python教程全套，现在分享给大家，入门到精通(Python全栈开发教程)_哔哩哔哩_bilibili就草草的记录了个大概，全是个人的记录，不具有参考价值，仅供自己遗忘时进行查看。