做题笔记

原始字符串结尾输入反斜杠：
str=r'C:dfadfasd\dfadf\dfasf\df''\\'
(不理解）

while 'C':
        print('dsfdC')

理解：会打印无数次，因为 'C' 为真。所以while一定要设置循环停止机制！
补充：能判断为假的只有：False,None，0,'',"",,[],{}

not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9
理解：短路逻辑：not> and >or 短路取1一个
（not 1） or （0 and 1） or （3 and 4） or （5 and 6） or （（7 and 8） and 9）
0 0 4 6 （8） 9
0 4 4 4 4
结果为4
floor() 向下取整。 //
assert(条件) 当条件为假时，中断程序
(x < y and [x] or [y])[0] 三元操作符？？？不理解
continue 测试循环条件，跳出本轮循环，直接进入下一轮
break 跳出循环
成员资格运算符 In()
列表增加：
append()：末尾增加一个元素
extend(),末尾增加，将参数作为列表去扩展列表末尾
name.append('c'), name.extend(['.','c'])
insert(索引位置，插入元素)
各种推导式和lambda
列表推导式：变量 = [输出的表达式 for 元素 in 列表 if 条件]
字典推导式：变量 = {输出的表达式 for 元素 in 字典 if 条件}
集合推导式：变量 = {输出的表达式 for 元素 in 列表 if 条件}
lambda:

list(filter(lambda x: not(x%3), range(1,100)))
#对应的列表推导式：
[i for i in range(1,100) if not(x%3)]

跨越多行的字符串： ''' ''' 或者 ' 第一行\ 第二行\ ' 或者 '每一行'
字符串方法及注释

字符串方法及注释1

字符串方法及注释2
file = open(r'C:\windows\temp\readme.txt', 'r')
因为\t \r 分别表示横向制表符tab 和回车符。所以要用原始字符串操作符。

字符串格式化

"{{1}}".format("不打印","打印")???? 不理解
关键参数在函数调用时，通过参数名制定需要赋值的参数，这样做就不怕因为搞不清楚参数的顺序而导致函数调用出错。而默认参数是在参数定义过程中，为形参赋初始值，当函数调用时，不传递实参，就默认使用初始值。
闭包

#调用：funout()
def funout():
    def funin():
        print("dfsadf")
    return funin()
#调用 funout()() 这是闭包
def funout():
    def funin():
        print("dsfd")
    return funin

zip 用法

>>>list(zip([1,3,5,7,9],[2,4,6,8,10]))
[(1,2),(3,4),(5,6),(7,8),(9,10)]

用lambda 和map 合并列表为列表

list(map(lambda x,y:[x,y],[1,3,5,7,9],[2,4,6,8,10]))

(map 是可以接受多个序列作为参数的）

递归两个基本条件: 函数调用自身 & 设置正确的返回条件
不得不使用递归的地方：汉诺塔，目录索引(永远不知道目录里是否还有目录)，快速排序，树结构定义等。会事半功倍
每一次调用，都需要进行压栈，弹栈，保存和恢复寄存器的栈操作，十分消耗空集和时间
字符分隔：

>>>data='1000,小甲鱼,男' 
>>>data.split(',')

字典的六种建立方法:

>>>a=dict(one=1,two=2,three=3)
>>>b={'one':1,'two':2,'three':3}
>>>c=dict(zip(['one','two','three'],[1,2,3])
>>>d=dict([('two',2),('one',1),('three',3)])
>>>e=dict({'three':3,'one':1,'two':2})

成员资格操作符检查一个key是否在字典中效率比检查一个元素是否在序列中高。因为字典的原理是哈希算法存储，一步到位，不需要查找算法进行匹配。时间复杂度是o(1)
所以字典的必须是可哈希的对象，不能使可变类型（包括变量，列表，字典本身等)
dict1.fromkeys(iterable, value=None)
创建一个新字典覆盖原有字典，复制它的Iterable和value
集合的作用：确保里面的元素唯一性。集合里不能有两个相同的元素。
集合里面是可哈希类型，所以也强调无序

将创建的集合不变： frozenset()
set.add(''), set.remove('')
打开文件

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

mode参数

文件对象方法

文件每行读入

for each_line in f:
  print(each_line)

获得文件指针位置: f.tell()

30.

集合内建方法总结
文件扩展名
长期使用Windows操作系统的朋友很容易被扩展名所误导，认为扩展名决定文件类型，其实这种观念是错误的！

其实这就跟一个姓张的坏人，尽管把名字改为了“张好人”，但他还是一个坏人是一个道理的^_

关于文件的扩展名，初学者容易走进的误区：

误区一：文件扩展名是一个文件的必要构成部分

一个文件可以有或没有扩展名，对于打开文件操作，没有扩展名的文件需要选择程序去打开它，有扩展名的文件会自动用设置好的程序（如有）去尝试打开（是“尝试打开”，而不是“打开”的原因参看下面的第2个误区），文件扩展名是一个常规文件的构成部分，但一个文件并不一定需要一个扩展名。

误区二：文件扩展名表明了该文件是何种类型

文件扩展名可以人为设定，扩展名为TXT的文件有可能是一张图片，同样，扩展名为M-P3的文件，依然可能是一个视频。

将文件另存为

f1=open('abc.mp3’)
f2=open('abc.txt')
f1.write(f2.read())

os 模块

os模块

os.path

pickle
存储

import pickle
content= 要存的信息，任意格式
pickle_file=open('content.pkl','wb')
pickle.dump(content,pickle_file)
pickle_file.close()

读取

pickle_file=open('contect.pkl','rb')
contentt=pickle.load(pickle_file)

异常

异常

try-except
try:
检测范围
except [Exception] as reason:
出现异常后的处理
except ([Exception],[Exception]) as reason:
出现异常后的处理

try-except-finally
try:
检测范围
except [Exception] as reason:
出现异常后的处理

finally：
无论如何都会执行的操作（放入必须执行的）

引发异常： raise exception
关闭文件，文件不存在的异常

try:
    with open('data.txt','w') as f:
        for each_line in f:
               print(each_line)
except OSError as reason:
    print('出错了'+ str(reason))

try:
    f=open('data.txt','w')
    for each_line in f:
           print(each_line)
except OSError as reason:
    print('出错了'+ str(reason))
finally:
    if 'f' in locals():
        f.close()

多个with
with A() as a, B () as b
访问私有变量:
p._Person_name
类的思想：
建立一个角色
角色的所有属性和行为都写在类里。

其他运行都写在外面

在子类的Init中继承父类

class Shark(Fish):
    def __init__(self):
        super().__init__()
        self.hungry=True

init魔法方法中返回值应永远是None
当子类定义了相同名字的属性或方法时，pthon不会删除父类相应的属性和方法，只是子类对象看不见。
横向类组合

class Pool:
    def __init__(self,x,y):
        self.turtle=Turtle(x)
        self.fish=Fish(y)
    def print_num(self):
        print(self.turtle.num, self.fish.num)

纵向类Mixin

48.

对象级别

属性会覆盖方法。
不要试图在一个类里定义所有的方法
尝试多使用组合。
继承机制虽然有用，但是会把代码复杂化，而且依赖隐含继承。
在有一个的场景里，使用组合
是一个的场景里，用继承
属性名用属性
方法名用动词
当属性和方法重名，属性会覆盖方法。

类属性和实例属性
num和count是类苏醒，x和y是实例属性。应使用实例属性而非类属性

class C:
    num=0
    def _init_(self):
        self.x=4
        self.y=5
        C.count=6

对象被实例化创建时，python会调用init。删除一个对象时，python解释器也会默认调用一个方法，这个方法为del()方法

class Ter:
    count=0
    def __init__(self):
        C.count+=1
    def __del__(self):
        C.count-=1

魔法方法

魔法方法

类构造器：
首先运行的是new魔法方法，然后运行init魔法方法
它的主要任务是返回一个实例对象，通常是cls这个类的实例对象，也可以返回其他对象。
new(cls[,...]) 第一个参数不是self而是cls，其他参数则会直接传给init
改变new方法

__new__
类的析构器（销毁）
就会运行delx`(self) 当没有变量引用的时候，就会出现垃圾回收机制，然后就会自动调用这个魔法方法。

i对象相加

当要继承的类是动态的，总是要变，可以给类取个别名

BaseAlias= BaseClass #为基类取别名

class Derived(BasedAlias):
    def meth(self):
        BaseAlias.meth(self) #通过别名访问基类

访问属性

getattr(类，'属性', '找不到提示')

使用property来统一接口
property(fget=None, fset=None, fdel=None, doc=None)

class C:
    def __init__(self,size=10):
        self.size=size
    def getSize(self):
        return self.size
    def setSize(self,value):
        self.size=value
    def delSize(self):
        del self.size
    x=property(getSize, setize, delsize)

属性访问api

描述符

描述符
容器

容器
迭代器

string='FishC'
it=iter(string)
while True:
    try:
        each=next(it)
    except StopIteration:
        break
    print(each)

yield 生成器，特殊的迭代器
出现yield，就会把yield后面的参数返回去。

def myGen():
    print('生成器被执行')
    yield 1
    yield 2

myG=myGen()
next(myG)
next(myG)
for i in myGen():
    print(i)

协同程序

协同程序
模块

模块
写完一个模块，在后面写一个test（）函数，进行测试。
并加上：
if name='main':
test()

只有自身调用才回调用test，这样就不会再运行程序的时候输出test内容

模块存储搜索路径
sys.path
一般是放在这里
'/Users/JuneZhu/anaconda3/lib/python3.6/site-packages',

加上搜索路径：
sys.path.append(路径')

包

包
PEP

image.png

image.png
print(timeit.doc)
dir(timeit)
timeit.all : 过滤后剩下的，可供外界调用的函数

并不一定每个模块都有all属性
当有all时：from timeit import all 只会导入可供调用的这些
当没有all时，就会导入所有没有下划线的。

file表示源代码所在的位置

静态方法，私有方法，公有方法

构造函数

析构函数

运算符

image.png

不断提升代码能力：

阅读高手代码
不断写代码

做题笔记

你可能感兴趣的:(做题笔记)