python笔记

%10s，表示10个字符的宽度

同上

%.3f，保留三位小数

%10.3f，宽10并保留三位小数

按位与，都是1才是1，其他全是0

按位或，有1就是1

按位异或，不同就是1

按位取反，0变1，1变0

左移动相应位数，高位丢弃，低位补0

右移动相应位数，低位丢弃，高位补0

+,-

false

数值0

None

空字符串

空列表

空元组

空字典

空集合

比较值

是否是同一个地址

判断当前对象是否是指定对象的子类

一个占位符：没想好if判断后执行啥，先pass占个位

判断语句成立执行语句1，否则执行语句2

结束当前循环，本层

结束当前循环，直接进入下次循环，本层

当循环中不执行break，则执行else

break会让else中的代码不执行，continue就没这个功能

字符串长度为0或者1

符合标识符的字符串（只包含字符 数字 下划线）

字符串只在编译时进行驻留，而非运行时

[-5,256]之间的整数数字

因为字符串的拼接和修改比较影响性能

join（）是先计算所有字符串的长度，再拷贝，只new一次对象，效率比+高

找不到报valueerror

找不到报valueerror

找不到返回-1

找不到返回-1

my_str.count(str, start=0, end=len(my_str))

参数第一个是宽度，第二个是填充符（默认空格）

如果宽度参数小于字符串长度，则返回原字符串

同上

同上

一个参数，如果是-87654，在 - 后面填0 

maxsplit是可选参数

只要是数字就行，中文数字，中文大写数字，罗马数字

这个就只是阿拉伯数字

将列表中的元素用 * 合并成一个字符串

单个字符当一个元素

ord('a')

chr(97)

从0到4

从6到最后

字符串

整数

浮点数

一共三位

三位小数

宽10位，共三位小数

word = "赞美愚者"
encoding1 = word.encode(encoding='GBK')  # GBK编码格式 一个中文两个字节
encoding2 = word.encode(encoding='utf-8')  # utf-8 一个中文三个字节
print(encoding1)
print(encoding2)

decoding1 = encoding1.decode(encoding='GBK')
decoding2 = encoding2.decode(encoding='utf-8')
print(decoding1)
print(decoding2)

lst = [2*i for i in range(1, 6)]
>>[2, 4, 6, 8, 10]

获取制定元素的索引（第一个）

获取列表中index为1的元素

lstChild = lst[start : stop : step]

判断元素是否存在

遍历

统计元素个数

查询元素的索引

append()

extend()

insert()

remove()

pop()

clear()

del

lst[index]=修改后的元素

lst[start:stop]=[........]

lst.sort(reverser=True),表示降序

lst.sort(key=function( ))

sorted(lst, reverser=True), 降序

将列表倒叙

python test.py 卢卡斯
>>卢卡斯

set([列表])

set((元组))

set("字符串")

用{}创建的是空字典

in

not in

s.add(一个元素)

s.update(至少一个元素)

s.remove(元素)

s.discard(元素)

s.pop()

s.clear()

del s

集合的元素为不可变类型，所以无法修改

==

！=

s1.issubset(s2)

s2.issuperset(s1)

s1.isdisjoint(s2)

s1.intersection(s2)

s1 & s2

s1.union(s2)

s1 | s2

s1.difference(s2)

s1 - s2

s1.symmetric_difference(s2)

s1 ^ s2

s4 = {2*i for i in range(1, 6)}
>>{2, 4, 6, 8, 10}

d = {item.upper() : value for item, value in zip(items, values)}

[键]

get(键)

key的判断

遍历

del a["name"]

del a

a.clear

a["新键"]=对应的值

a["要修改的键"]=新值

获取字典中所有的键（key）

获取字典中所有的值（value）

获取字典中所有的键值对（key.value）

print(item)

print(a[item])

print(a.get(item))

[x for x in range(4)]

加条件

for嵌套循环

# 这样可以去键值对
for k,v in dict.items():
        print(k, v)

返回长度

返回最大值

del a或者del(a)

稍后再说

用到再说

a和b

a和b的实际值

结果是元组

结果是字典

*之后的参数只能用关键字参数传递

不过这样也可以def fun(a, b, *, c, **arges)
因为本质上它还是只有一个关键字参数，*只不过是个条件

def fun(a, b, c):
    print('a=', a)
    print('b=', b)
    print('c=', c)

要在函数内修改全局变量，先用global声明

def fun(a, b, opt):
    print(opt(a, b))

fun(1, 4, lambda x, y: x+y)

阶乘函数
def fac(n):
    if n == 1:
        return 1
    else:
        res = n*fac(n-1)
        return res

斐波拉契数列
F[n]=F[n-1]+F[n-2]  (n>=2,F[0]=0,F[1]=1)

python中一切皆对象
有id（内存空间），有type（数据类型），有值

一般首字母大写，其余小写

可以在外面通过Student.gender = None，加一个类属性

当通过实例对象调用方法的时候，self能够自动指向实例对象，从而拥有了操作这个对象中的属性或者方法的可能。

静态方法之所以不需要self，是因为方法内不需要实例对象的引用

能获取构造函数定义的变量，也不可以获取类的属性。

不能获取构造函数定义的变量，可以获取类的属性。

对象名.方法名

类名.方法名（类的对象）----方法定义处的self

调用属性

类中方法外的变量，被该类所有对象共享

使用类名直接访问的方法

使用类名直接访问的方法

再用B.aa就可以调用A的属性和方法了

如果属性不希望被外部调用，可以前面加2个_

没写父类的默认继承object

定义子类时，要在构造函数中调用父类的构造函数

支持多继承

单继承

1.super().__init__相对于类名.__init__，在单继承上用法基本无差
2.但在多继承上有区别，super方法能保证每个父类方法只会执行一次，而类名.方法()会导致方法可能被执行多次
3.多继承时，用super方法，对父类传参，由于super的算法，必须把参数全部传递，否则报错，所以就要加上*args和**kwargs
4.单继承时，用super方法，不用全部传参，只能传父类方法所需的参数，否则报错
注：在多继承时，尽量不用super，用父类名.方法（）
用super虽然对于同个父类的调用可以避免重复执行，但代码阅读难度增加，不利于debug

所有类的父类

子类想输出自己独有的东西，父类没有

反正就是调用类的方法很方便

class Dog():
    def bark(self):
        print("普通狗汪汪叫")


class LangDog(Dog):
    def bark(self):
        print("狼狗狂吠")


class ZangAo(Dog):
    pass


class Person():
    def pk_dog(self, dog):
        print('人向狗进行了攻击')
        dog.bark()


Anna = Person()
dog1 = Dog()
dog2 = LangDog()
dog3 = ZangAo()

Anna.pk_dog(dog1)
Anna.pk_dog(dog2)
Anna.pk_dog(dog3)

如果需要当前类做多个实例化，则只需要创建一个空间来存储实例对象

用户访问属性，传入一个参数，可以返回提前设定好的值

输出类的说明描述。类的说明写在类名下一行，__doc__只调用那段注释。

一般不去改

当成函数去用，就可以传参了

返回值只接受string

字典
一定要用foo['hahaha']操作才能调用这三个方法

gender属性只有stu1有

show()只有stu1能调用

@property
    def func(self):
        return '调用func'

foo = Foo()
res = foo.func

'''
对于京东商城中显示电脑主机的列表页面，
每次请求不可能把数据库中的所有内容都显示到页面上，
而是通过分页的功能局部显示，
所以在向数据库中请求数据时就要显示的指定获取从第m条到第n条的所有数据 这个分页的功能包括：
1.根据用户请求的当前页和总数据条数，计算出m和n
2.根据m和n去数据库中请求数据
'''

>>100

第一个参数是方法名，调用 对象.属性 时自动触发执行方法
第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数是字符串，调用 类名.属性.__doc__ ，此参数是该属性的描述信息
注：property中的参数顺序一定要按照get set del排序

>>num1是可引用内容
>>100
>>AttributeError:不拉不拉，test_1没num2这个属性

new和init的传参过程

for

while

1. 先定义主要类

2. 给这个类定义一个迭代器

3. MyList的实例对象my_list这时就可以用for循环遍历了

对比

原因

例

1.send方法与next方法类似
2.可以向生成器传递一个参数，并在生成器中进行接受
3.一般不在第一次获取值时使用，第一次获取时必须传递None
    print(my_iter.send(None))
4.可以在程序运行的过程中对当前的函数运行过程进行操作

关闭当前生成器（相当于删除或销毁）

return：代表整个函数结束，结束前返回值，函数中只能有一个，生成器中不可以有return
yield：不代表函数结束（只是暂停），返回一个生成器对象（可用next取到其值），函数中可以写多个yield

def person():
    def info():
        xxxxxx
p = person()  # 这里只引用了info（），并没有调用，所以info没有运行，此时person（）这个函数还是占着内存
p（）  #  这样就运行了info（）这个函数，运行完就会释放内存

>>内部函数的参数为： 10
>>30

>>[DEBUG]: enter say_hello()
>>hello

效果一样，这是最简单的装饰器，被装饰函数无法传参

>>[DEBUG]: enter say()
>>hello! lucas

>>info: enter function say()
>>hello lucas

装饰器要求接收一个callable对象，并返回一个callable对象。
所以类装饰器中，__init__接收函数，重载__call__()并返回一个函数
一个装饰器可以装饰多个函数
一个函数可以有多个装饰器（很少用）

将它赋值给一个变量

拷贝它

为它增加属性

将它作为函数参数进行传递

创建一个类

实例对象由类对象创建，所以type（实例对象），出来的是对应的类
而类对象是由type创建，所以type（类对象），出来的是type。
object也是类，所有类都继承于object，但其创建者是type

type函数的第二种用法（自己写函数不要让一个函数有两种完全不同的功能）

例

例

只执行一个分支

except后面跟一个元组

自定义的异常要继承Exception

先定义一个异常类

在函数中主动抛出异常

调用函数

str_1='d52a733i2327ha244i982d23s553b245'

https://docs.python.org/zh-cn/3.9/library/exceptions.html#exception-hierarchy

不知道会有什么异常就用这个

'r'

'a'

'w'

‘w+’

'x'

't'

'b'

'rb'

'wb'

'ab'

'wb+'

注意：尽量一次只用一种模式，+模式好像不太好用

从根文件夹开始

相对于当前工作目录的路径

文件名这里写路径，不论是绝对路径还是相对路径