疯狂python讲义笔记——持续更新(一)

时间:2020-6-30 作者:admin
#第一章:绪论
#单行注释
'''
多行注释
'''
"""
多行注释
"""

#dir列出指定类或模块的属性与方法,help查看某个函数或方法的帮助文档
print(dir(str))
print(help(str.title))



#第二章:数据类型
a=5
print(type(a))#<class 'int'>
b=5.
print(type(b))#<class 'float'>
c=None
print(type(c))#<class 'NoneType'>
d='abc'
print(type(d))#<class 'str'>
e=str(a)+d
print(e,repr(e),e[1],e[-2],len(e))#5abc '5abc' a b 4
f=''' "I am " a good 'boy' '''
print(type(f),f[11:13])#<class 'str'> go
print('od' in f)#True
print('aa' not in f)#True

#输出(好像装了torch后不能Input,算了,反正也用不着控制台)
import sys
f=open("1.txt",'w')
print(a,b,sep='c',end='',file=f,flush=False)#5c5.0
print(a,b,sep=' ',end='\n',file=sys.stdout,flush=False)#5 5.0
#separate分隔符,end结束符,file输出到哪,flush缓冲

#变量名:字母数字下划线,不可数字打头不可如下关键字,可内置函数名但会覆盖
import keyword
print(keyword.kwlist)
'''
['False'假, 'None'空值, 'True'真, 'and'与, 'as'作为, 'assert'异常, 
'break'中断, 'class'类, 'continue'继续, 'def'定义, 'del'删除, 
'elif'否则若, 'else'否则,'except'异常, 'finally'最终, 'for'循环, 
'from'从, 'global'全局, 'if'如果, 'import'导入, 'in'里, 'is'是, 
'lambda'匿名函数,'nonlocal'非本地, 'not'否, 'or'或, 'pass'省略, 
'raise'异常, 'return'返, 'try'异常,'while'当, 'with'伴随, 'yield'生成器]
'''

#转义字符
s='F:\ProjectPython\hello_test'
print(s)#无转义字符
s='F:\rojectPython\bello_test'
print(s)#有转义字符
s=r'F:\rojectPython\hello_test'
print(s)#取消转义字符
'''转义字符
\b退格退一空格,\n换行下一行,\r回车回行首,\t制表输入四个空格
\"双引,\'单引号,\\反斜线
'''

#str封装类的方法
ss='   abc def   '
print(repr(ss.title()))#'   Abc Def   ' 
print(repr(ss.upper()))#'   ABC DEF   '
print(repr(ss.lower()))#'   abc def   '
print(repr(ss.strip()))#'abc def'
print(repr(ss.lstrip()))#'abc def   '
print(repr(ss.rstrip()))#'   abc def'
ss='I love GJL'
print(ss.startswith('I'))#True
print(ss.endswith('GJL'))#True
print(ss.find('o'))#3,找不到返-1
print(ss.index('o'))#3,找不到报错
print(ss.replace('love','like'))#I like GJL
print(ss.split('o'))#['I l', 've GJL']
print(ss.split(None,1))#['I', 'love GJL']
print('.'.join(ss.split(None,1)))#I.love GJL

#运算符
a=5
b=2
c=1/2#若除以0会产生ZeroDivisionError
s='cj'
print("a>b") if a>b else print("a<b")#a>b,在输出层面的三目运算符
print("a>b" if a>b else "a<b")#a>b,先判断返回哪个字符串再输出
print(a,a+b,a-b,a*b,a/b,a//b,a**b,a%b,b*s,s*b)#5 7 3 10 2.5 2 25 1 cjcj cjcj
print(a**c,a&b,a|b,a^b,~a,a<<2,a>>2)#2.23606797749979 0 7 7 -6 20 1
print(a==b,a!=b,a>b,a>=b,a<b,a<=b,a is b)#False True True True False False False
s='0123456789'
print(s[2:8:2])#246,下标2到下标8前一位,步长为2
import time
a=time.gmtime()
b=time.gmtime()
print(a==b,a is b)#True False
a=True
b=False
print(a and b,a or b,not b)#False True True



#第三章:列表与元组(其实有列表就够用)
#先用dir(list)查看可用方法
print(dir(list))#会用下面的方法就表示掌握了List封装类
'append'#加加
'clear'#清空
'copy'#复制
'count'#计数
'extend'#追加
'index'#找下标
'insert'#插入
'pop'#出队/退栈
'remove'#删除
'reverse'#翻转
'sort'#排序
a=['abc','def','ghi',11]#列表可修改
b=('123','456','789',22)#元组不可改
bb=2,5,7,3,6,9
print(type(bb))#<class 'tuple'>默认是元组
d=['GJL']
print(b+(520,))#('123', '456', '789', 22, 520),相当于append方法,注意(520)是520非元组只是Int
print(a+d)#['abc', 'def', 'ghi', 11, 'GJL'],相当于extend方法
print(d*2)#['GJL', 'GJL']
print(a[0:3:2],b[0:-2:2])#['abc', 'ghi'] ('123',),索引[start:end:step]
print('123' in b,b.index('123'))#True 0,跟前面str很类似
c=[1,3,5,7,9,2,4,6,8,0]
print(len(c))#10
#封包
a_tuple=tuple(range(1,10,2))
a_list=list(range(1,10,2))
print(a_tuple,a_list)#(1, 3, 5, 7, 9) [1, 3, 5, 7, 9]
#解包
a,b,*c,d=a_list#a_tuple也可,*c表示后面若干个的生成一个列表
print(a,b,c,d)#1 3 [5, 7] 9
#封解包结合实例:swap
x,y=1,2
x,y=y,x#swap
print(x,y)#2 1
#列表增删改查(比C++中的链表方便多了)
a=[1,3,4]
b=[25,6,]
a.insert(1,2)
print(a[0],a[1],a[2],a[3])#1 2 3 4,下标越界如访问a[4]会产生IndexError
a.append(b)
print(a)#[1, 2, 3, 4, [25, 6]]
a.extend(b)
print(a)#[1, 2, 3, 4, [25, 6], 25, 6]
del a[2]
print(a)#[1, 2, 4, [25, 6], 25, 6]
del a[2:5:2]
print(a)#[1, 2, [25, 6], 6]
a.remove([25, 6])
print(a)#[1, 2, 6],注意找不到要删除的目标时会报错,此时需要写异常来接收使程序继续
a.sort(reverse=True)#升序
print(a)#[6, 2, 1]
a.reverse()
print(a)#[1, 2, 6]
a.pop()#python真的是一个list就代替了C++中的栈与队列
print(a)#[1, 2]
print(a.count(2))#1
a.clear()#a[0:len(a)+1]=[]是一样的功能
print(a)#[]
#补充一下sort中的key,相当于C++中常写的cmp函数
#第一种是用.sort形式,是类方法会改变类对象自身
a=[]
a.extend(range(1,10,2))
a.extend(range(10,2,-2))
print(a)#[1, 3, 5, 7, 9, 10, 8, 6, 4]
def cmp(x):#自定义比较函数
    return x%3#用%3之后的值来比较
a.sort(key=cmp)#注意当%3后的值相等时按原顺序,即稳定的排序算法
print(a)#[3, 9, 6, 1, 7, 10, 4, 5, 8],默认升序
#第二种是用sorted形式,是全局方法不会改变传入的参数
a=['ab','d','cac']
print(sorted(a,key=len,reverse=True),a)#['cac', 'ab', 'd'] ['ab', 'd', 'cac']

#字典(对应C++中的map),元组可作key因为规定不可变
print(dir(dict))
'clear'#清空
'copy'#复制
'fromkeys'#根据key与val生成字典
'get'#根据key查val,查不到返none,用[]的话会报错KeyError
'items'#获取所有数据对
'keys'#获取所有key
'pop'#由key删除
'popitem'#删除底层存储的最后一个元素
'setdefault'#更新dic,没有该key的话就创建,有该Key的话不修改
'update'#更新dic,没有该key的话就创建,有该Key的话修改为新值
'values'#获取所有val
s='a'
x={1:'ABC',s:'DEF',2:'GHI',4:234}
s='b'#s与x无关
y=x#浅拷贝
z=x.copy()#深拷贝
x[1]='GJL'
print(x)#{1: 'GJL', 'a': 'DEF', 2: 'GHI', 4: 234}
print(y)#{1: 'GJL', 'a': 'DEF', 2: 'GHI', 4: 234}
print(z)#{1: 'ABC', 'a': 'DEF', 2: 'GHI', 4: 234}
#增删改查
x[34]=56
print(x)#{1: 'GJL', 'a': 'DEF', 2: 'GHI', 4: 234, 34: 56}
x[34]=45
print(x)#{1: 'GJL', 'a': 'DEF', 2: 'GHI', 4: 234, 34: 45}
del x[34]
print(x)#{1: 'GJL', 'a': 'DEF', 2: 'GHI', 4: 234}
print(1 in x)#True
print(x.get(4))#234
x.pop(2)#同del x[2]
print(x)#{1: 'GJL', 'a': 'DEF', 4: 234}
x.popitem()
print(x)#{1: 'GJL', 'a': 'DEF'}
x.update({1:'ABC','a':'DEF',2:'GHI'})
print(x)#{1: 'ABC', 'a': 'DEF', 2: 'GHI'}
for i in x.items():
    print(i,i[0],i[1],end=',')#(1, 'ABC') 1 ABC,('a', 'DEF') a DEF,(2, 'GHI') 2 GHI,
    print(type(i))
for i in x.keys():#注意等价于for i in x:即x默认取出来就是Key
    print(i,end=' ')#1 a 2 4
for i in x.values():
    print(i,end=' ')#ABC DEF GHI 234 
my_key = ('G', 'J', 'L')
my_val = 'C','J'
new_dic=dict.fromkeys(my_key, my_val)
print(new_dic)#{'G': ('C', 'J'), 'J': ('C', 'J'), 'L': ('C', 'J')}
new_dic.setdefault('love',520)
print(new_dic)#{'G': ('C', 'J'), 'J': ('C', 'J'), 'L': ('C', 'J'), 'love': 520}
new_dic.setdefault('G',520)
print(new_dic)#{'G': ('C', 'J'), 'J': ('C', 'J'), 'L': ('C', 'J'), 'love': 520}
my_key='my name is %(name)s, my age is %(age)d years old, my weight is %(weight)f kg'
my_val={'name':'CJ','age':24,'weight':50.0}
s=my_key % my_val#这样可以获得一个字符串
print(s)#my name is CJ, my age is 24 years old, my weight is 50.000000 kg
#最后补充四点
#第一点:字典中取出来的数据类型
x={1:'ABC','a':['DEF',45],2:'GHI'}
for i in x.items():
    print(i,i[0],i[1],end=',')
    print(type(i),type(i[0]),type(i[1]))
'''
(1, 'ABC') 1 ABC,<class 'tuple'> <class 'int'> <class 'str'>
('a', ['DEF', 45]) a ['DEF', 45],<class 'tuple'> <class 'str'> <class 'list'>
(2, 'GHI') 2 GHI,<class 'tuple'> <class 'int'> <class 'str'>
'''
#第二点:元组与列表转换元组并非不可改变,及append与extend区别
kk=(12,34)#不可修改的元组
tmp=list(kk)#转换成列表
tmp2=tmp*3
tmp2.append('abc')
tmp2.extend('abc')
print(tmp2)#[12, 34, 12, 34, 12, 34, 'abc', 'a', 'b', 'c']
kk=tuple(tmp2)#再转回元组
print(kk)#(12, 34, 12, 34, 12, 34, 'abc', 'a', 'b', 'c')
#第三点:实现字母遍历用ord字符改ASCII与chrASCII码改字符
s='ABCABCABCDE'
dic={}
for x in range(ord('A'), ord('E') + 1):
    tmp=s.count(chr(x))
    dic[x-64]=tmp
print(dic)#{1: 3, 2: 3, 3: 3, 4: 1, 5: 1}
#第四点:zip写法
a=[1,3,5]
b=[2,4,6]
c=zip(a,b)
print(type(c))#<class 'zip'>
for x,y in zip(a,b):
    print(x+y)#3 7 11就是打包后再解包得到两个int
for x in zip(a,b):
    print(x,x[0],x[1],type(x))#跟dic一样用一个变量取就是<class 'tuple'>



#第四章:流程控制
if 1:
    pass
elif 1:
    pass
else:
    pass
while 0:
    break
else:
    pass
s='abc'
assert s=='abc'#断言,若不符合会产生AssertionError,若符合则继续往下执行
for i in range(0,len(s),1):
    continue
else:#python中所有循环后都可以用else,其唯一作用是延长这个代码块的临时变量作用域
    print(s[i])#注意i在else块中的值是最后一次符合循环条件的值
for i in s:#除了像上面遍历下标外还可以直接遍历每个元素
    print(i)
b=[(x*x,y) for x in range(2) for y in reversed(range(3))]#for嵌套生成列表
print(b,type(b))#[(0, 2), (0, 1), (0, 0), (1, 2), (1, 1), (1, 0)] <class 'list'>
b=(x*x for x in range(10) if x%2==1)#for与if表达式嵌套生成生成器
for i in b:
    print(i,end=' ')#1 9 25 49 81 
print(b,type(b))#<generator object <genexpr> at 0x000001AAC17255C8> <class 'generator'>



#第五章:函数
def cjmax(a,b,c,d=2):#痛苦,一开始用了max做函数名覆盖了内置函数致前面第二章处报错
    '''
    return a tuple#返回一个元组
    '''
    return a,b,c,d
print(cjmax.__doc__)#return a tuple#返回一个元组
print(help(cjmax))
'''
Help on function cjmax in module __main__:
cjmax(a, b, c, d=2)
    return a tuple#返回一个元组
None
'''
print(cjmax(1,c=3,b=2))#(1, 2, 3, 2),传参顺序:不带名传参,带名传参(可换位),带默认值的参数(可省)
#四个例子说明传参问题
def cjswap1(w,x,y,z):
    w[0],w[1]=w[1],w[0]
    x[1],x[2]=x[2],x[1]
    y,z=z,y
    w=None#栈中指针清空并不改变指向的堆内存数据
    x=None
w=[8,9]
x={1:2,2:3}
y=6
z=7
cjswap1(w,x,y,z)
print(w,x,y,z)#[9, 8] {1: 3, 2: 2} 6 7,列表字典传参是本体,普通传参是值传递
def cjswap2(*x,y):#用*来传参会打包生成tuple,若后面还有参数传入时必须显式传参如例中的y
    #x[0],x[1]=x[1],x[0]#TypeError: 'tuple' object does not support item assignment
    return x[0],x[1]
x,y=cjswap2(1,2,y=3)
print(x,y)#1 2
def cjswap3(*x,**y):#**y用于收集字典,参数顺序尽量是无*,带*,带**
    print(x)#('I', 'love', 'GJL')
    print(y)#{'cj': 'gjl', 'gjl': 'cj'}
cjswap3('I','love','GJL',cj='gjl',gjl='cj')
def cjswap4(x,y):
    print(x,y)#1 2
cjlist=[1,2]
cjswap4(*cjlist)#带*就是解列表包
cjtuple=(1,2)
cjswap4(*cjtuple)#带*就是解元组包
cjdic={'x':1,'y':2}
cjswap4(**cjdic)#带**就是解字典包
#变量字典
#先弄个全局变量
age=100
name='cj'
love='gjl'
def test(x):
    print(globals())#全局范围所有变量
    age=20#默认局变量20遮盖了全局的100
    print(age)#20
    print(globals()['name'])#访问全局变量中变量名为name的变量,cj
    global love#声明本函数作用域内的love用的是全局变量,这就可以对全局变量作修改了
    love='jl'
    print(love)#jl
    print(locals())#局部范围所有变量,在全局范围调用同globals,{'age': 20, 'x': 1}
    print(vars(test))#对象范围所有变量,不传参的话同locas,{}
test(1)
print(age)#100
print(love)#jl
#函数内的函数以及函数换名三方法
def f1(x):
    print(type(x))#由执行时传入参数决定<class 'int'>或<class 'float'>
    def f2(y):
        return y+1
    return f2(x+1)
print(f1(1.0))#3
#一、直接换名
f3=f1
print(f3(1))#3
#二、传参是函数
def f4(f,x):
    return f(x)
print(f4(f3,1))#3
print(type(f4))#<class 'function'>
#三、返参是函数
def f5():
    return 1
def f6():
    return f5
f=f6()
print(type(f),f,f())#<class 'function'> <function f5 at 0x000001AAC17CE840> 1
#lambda
y=lambda x:x*x#单行函数且只用一次
def z(x): return x*x#与上面等价
print(y(2))#4
print(z(2))#4



#第六章:类与对象
#基本属性与方法
class stu:
    def __init__(self,name='cj'):
        self.name=name
    def say(self,content):
        print(self.name,content)
p1=stu()
print(p1.name)#cj
p1.say('loves GJL')#cj loves GJL
#动态增减属性
p1.age=24#给p1动态增加属性age
del p1.name
print(vars(p1))#{'age': 24}显然p1可以动态增加name属性
p2=stu()
print(vars(p2))#{'name': 'cj'}显然p2并没有age属性即对象之间无影响
print()
print()
print()
#动态增减方法(不能删原有的say)
#第一种常规
def fun_func1():
    print("running")
p1.run=fun_func1#动态增加方法
p1.run()#running
del p1.run#动态加的方法可以删
#第二种要访问类对象属性时加self
p3=stu()
def fun_func2(self):#若是要访问类属性及类方法记住都加上self
    print(self.name)
p3.introduce=fun_func2
p3.introduce(p3)#cj,必须传p3做参数
#第三种要访问类对象属性时用绑定
from types import MethodType
p4=stu()
p4.introduce=MethodType(fun_func2,p4)
p4.introduce()#cj,绑定后调用时就不用传p4做参数了,跟类定义时就确定的方法一样
#连续调用的写法
class stu2:
    def __init__(self):
        self.age=10
    def grow(self):
        self.age+=1
        return self
cj=stu2()
cj.grow().grow().grow()
print(cj.age)#13
#类调用方法
class stu3:
    def __init__(self,name):#name没有默认值则创建对象时必须构造一个
        self.name=name
    def run():
        print("nobody is running")
    def run2(self):
        print("someone is running")
stu3.run()#nobody is running,类调用方法
stu3.run2(stu3('cj'))#someone is running,有self传入的话也要传入一个
#类方法与静态方法(一般不需要用到,工厂模式下才需要)
class stu4:
    def __init(self):
        self.age=20
    @classmethod
    def run(self):
        pass
    @staticmethod
    def jump(self):
        pass
stu4.run()#类方法与一般对象方法一样是绑定self第一参数传入的
stu4.jump(stu4())#静态方法与类外扩展定义的动态方法是不绑定的所以要传入一个对象

 

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:87074139@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。