Python的笔记

最新推荐文章于 2023-01-08 20:18:11 发布

麻达拉

最新推荐文章于 2023-01-08 20:18:11 发布

阅读量258

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/qq_43346054/article/details/104134469

版权

Python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

API文档不会查呀

字符串：

a='a=hello world111'

#这种形式的换行符不会被打印，python会认为 \ 后面的也是属于b的
#python不是自由格式的语言
b='b=hello ' \
  'world222'
c='''c=hello world333'''
#这种形式的换行符会被打印出来
d='''d=hello 
world444'''
e=[a,b,c,d]
for i in e:
    print(i)

#转义字符
t1='''I'm Tom'''
print(t1)
t2='I\'m Tom'
print(t2)
t3="I'm Tom"
print(t3)

#切片
str1='012345678'
print(str1[0:9:2])
print(str1[::-2])
print(str1[3::-2])
#***注意：切片的时候步长要与下标方向相同**
print(str1[-1:-5:-2],end='步长与切片方向相同')#
print(str1[2:5:-1],end='步长与切片方向相反\n') #这个时候就不会输出任何内容了

#find方法：
ss='0123456789000999234'
s1='012'
s2='789'
print(ss.find(s1))
print(ss.find(s2,0,9))#说明不包含后面这一个位置
print(ss.find(s2,0,10))#说明不包含后面这一个位置
print(ss.find(s1,0))

#cout方法:
print(ss.count('0'))
print(ss.count('0',1,))
print(ss.count('0',1,12))

列表：

name=['xiaoli','xiaohong','xiaoming']
#index方法查找规则，左闭右开
#print(name.index('xiaoming',0,2)) #报错，因为返回异常。找不到。
print(name.index('xiaoming',0,3))
print(name.index('xiaoming',0,len(name)))

#count方法,内部只有一个参数，返回查找对象出现的次数
print(name.count('xiaoming'))

#公共函数，len，用于统计列表中的元素个数
print(len(name))

#in运算符，某个元素判断是否存在于列表
'''
in 运算符与 not in 运算符返回值都是bool类型
True或者False
'''
print('hh' in name)
print('hh' not in name)

#列表中增加数据
'''
列表增加数据的方法：
1 append()  在列表结尾增加数据
这个数据也可以是一个序列，在追加的时候是以序列的形式整体
加到列表里的（见程序）。
2 extend()  在列表结尾增加数据
将数据序列拆开，然后加到列表的结尾。
3 insert()  在指定位置增加数据
将数据序列整体加入到列表当中，不将数据序列拆开
'''
#append方法
name.append('Mike')
print('使用append后:',name)
num_bulm=[1,2,3]
name.append(num_bulm)
print('1 注意追加列表的形式',name)
#返回一个异常，因为name这个列表中没有1这个数据，序列是整体加入的
#print(name.index(1))
#再次证明序列是整体加入列表的
print(name.index(num_bulm))

#extend方法：
name=['xiaoli','xiaohong','xiaoming']
#字符串也是一个序列，会被拆开
name.extend('123456')
print(name)
name=['xiaoli','xiaohong','xiaoming']
#这样写才不会将字符串拆开
name.extend(['123456'])
print(name)

#insert方法
name=['xiaoli','xiaohong','xiaoming']
name.insert(1,'新的一个变量')
#可见没有将数据序列拆开
print(name)
Lit=[1,2,3]
name.insert(1,Lit)
#可见没有将数据序列拆开
print(name)

#列表中删除数据
'''
1 del  可以写括号，也可以不写括号 del(x) / del x
    1 删除列表
    2 删除列表中指定下标的数据
    3 它应该是一个内置函数，不是特定的方法
2 pop   内置方法
    删除列表中的元素，返回值是被删除的那个元素
    1 可以删除列表中指定下标的数据
    2 如果不指定下标，就删除最后面的元素
3 remove 内置方法
    删除列表中指定元素(只能删除一个)
4 clear 内置方法
    清空列表
'''

#del
name=['xiaoli','xiaohong','xiaoming']
del name[0]
print(name)


#pop
name.append('123')
print(name)
tt=name.pop()
print('被删除的元素',tt,'删除后的列表',name,sep=';;')

#remove
Lst=[1,1,2,3,4,55,55,6,6,6]
Lst.remove(6)
print(Lst)

#clear
Lst.clear()
print(Lst)

#列表是引用数据类型（所以，python的面向对象都是引用数据类型？）
lst=[1,2,3]
lst2=lst
#lst.sort(reverse=True)
lst.pop()
print(lst2)
#由于是引用数据类型，所以我们要用copy方法
lst2=lst.copy()

#循环遍历
lst=['1[]','2[]','3[]','4[]','5[]']
i=1
while i <len(lst) :
    print(lst[i],'*')
    i+=1
for i in lst:
    print(i)

列表的一段程序

'''
随机分配办公室
'''
import random
teachers=['a','b','c','d','e','f']
office=[[],[],[]]
'''
randint()这个方法里的参数取值时是左右均闭的。
之前那种左闭右开可能是为了防止取到：length（）。
举个例子，由于字符串的下标是从0到len-1，如果字符串的方法右闭的话，
写起来会有一些麻烦。
'''
for name in teachers :
    room=random.randint(0,2)
    #这里要用append方法来为列表增加元素
    #因为名字是一个整体
    office[room].append(name)
for i in office:
    print(i)

函数

"""
函数的格式：
def 函数名 （参数列表（无类型））:
    程序块
"""


#函数的调用以及说明文档的写法
def testA ():
    #说明文档的写法
    '''
    学习测试函数
    输出
    :return:
    '''
    print('testA开始')
    print('testA执行结束')
def testB():
    print('testB开始')
    testA()
    print('testB执行结束')

testB()
help(testA) #调用说明文档

#一个函数返回多个返回值
def MulInt():
    return 1,2
print(MulInt())#默认多返回值是一个元组

def MulList():
    return [1,2],[55,66]#可以返回多个列表
print(MulList())

拆包：

'''
拆包(unpack)（主要学元组和字典的拆包）：
    拆包是组包的逆过程，就是把一个整体数据拆开。
'''
print("'以下是拆包的内容'")
#拆包元组数据：
def return_num():
    return 100,200#返回两个变量，所以返回类型是一个元组
   # return 100,200,300 #由于是用两个变量，所以返回unpack error
num1,num2 = return_num() #用两个变量来接收，就可以将元组拆开
print(num1)
print(num2)
#拆包字典数据：
dic1={'name':'Tom','age':18}
#对字典进行拆包，取出来的是字典的key（键值）
name,age=dic1
print(name)
print(age)
#想要得到字典的value：
print(dic1[name])
print(dic1[age])

变量+引用

'''
Python中特有的赋值以及交换变量的方式。
'''
a,b=1,2 #等同于a=1，b=2
print('交换之前')
print(a)
print(b)
b,a=a,b#交换变量
print('交换之后')
print(a)
print(b)

'''
引用：
    结论：在python中，值是靠引用来传递的。
'''
a=1
b=a
print(id(a))#打印变量a指向的的内存地址
print(id(b))#打印变量b指向的的内存地址

'''
不可变数据类型与可变数据类型：
    int ：不可变数据类型。
    列表 ：可变数据类型。
'''
'''
int类型(不可变)：
'''
a=2
print(b)#这里，虽然改变了a的值。但b的结果依然是1。
#可以发现，a指向的内存地址变化了。
print(id(b))
print(id(a))
'''
列表（可变）：
'''
c=[55,66,77]
d=c
#可以发现，d与c指向的地址相同
print('id(c)=',id(c))
print('id(d)=',id(d))
#由于是可变引用，d的值也会变化
c.append(999)
print(d)

'''
引用当作实参：
    引用可以当作实参，比如int类型（不可变数据类型）的引用，或者列表（可变数据类型）等其
    他类型的引用。
测试：
    1.1 访问打印形参看是否有数据。
    1.2 访问形参的id，查看与实参的id是否相同。
    1.3 改变形参的数据，查看这个形参是否打印id，看修改前后形参的id值是否相同。
'''

def test1(b):
    print('id b = ',id(b))
    print('b= ',b)
    b+=b
    print('b = ',b)
    print('id b = ',id(b))#int是不可变数据类型，所以该id与形参初始id不同
#不可变数据类型
e=100
print('id e = ',id(e))
test1(e)
print(e) #e的值依然是100，也就是说，传入引用但不会改变引用。

'''
可变数据类型和不可变数据类型：
    1.1可变数据类型是指修改时能对原数据直接修改的，否则就是不可变数据类型。
    1.2可变数据类型：
         列表
         字典
         集合
    1.3不可变类型：
         整形
         浮点型
         字符串
         元组
'''

综合应用——学员成绩管理：

#由于还不会文件读写，所以声明一个列表来存储学员的所有信息
info=[]#每位学员的信息都存储到字典中（一个字典对应一个学员），再将字典添加到列表中

#打印开始界面
def info_print():
    print('********选择功能********')
    print('1.添加学员')
    print('2.删除学号')
    print('3.修改学号')
    print('4.查询学号')
    print('5.显示所有学员')
    print('6.退出系统')
    print('-'*25)

#添加学员信息的函数
def add_info():
    new_id=input('输入学号')
    new_name=input('输入姓名')
    new_tel=input('输入电话号码')
    global info #声明对全局变量进行操作
    #先判断新输入的用户是否已经存在
    for i in info:
        if new_name==i['name']:
            print('该用户已存在')
            return
    #该用户不存在，则添加学员信息
    stu_dic={}
    #将用户的信息添加到字典
    stu_dic['id']=new_id
    stu_dic['name']=new_name
    stu_dic['tel']=new_tel
    #将字典添加到列表
    info.append(stu_dic)

#删除学员信息的函数
def delete_info():
    #1.输入要被删除的学生的姓名
    del_name=input('输入要删除的学生的姓名')
    flag=True
    global info
    for i in info:
        if i['name']==del_name:
            info.remove(i)
            flag=False
            break
    if flag:
        print('没有该学员的信息')
    else:
        print(info)
#修改学员信息
def modify_info():
    #输入要修改的学员的姓名
    mod_name=input('输入要修改的学员的姓名')
    global info
    for i in info:
        if i['name']== mod_name:
            i['tel']=input('输入修改后的电话号码')
            break
    else:#如果for循环正常结束。
        print('该学员不存在')
    print(info) #无论是否修改，都打印全体学员

#查询学员信息
def search_info():
    search_name=input('输入要查找的')
    global  info
    for i in info:
        if i['name']==search_name:
            print(f"学号：{i['id']},姓名：{i['name']},电话号码：{i['tel']}")
            break
    else : print('未查询到该学员信息')

#打印所有学员的信息
def print_all():
    global  info
    print('*'*25)
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")
    print('*'*25)

#循环主体
while True:
    info_print()
    user_num=int(input('输入功能序号'))
    if user_num==1:
        #print('添加学员')
        add_info()
    elif user_num ==2:
        #print('删除学员')
        delete_info()
    elif user_num==3:
        #print('修改学员')
        modify_info()
    elif user_num==4:
        #print('查询学号')
        search_info()
    elif user_num==5:
        #print('显示所有学员')
        print_all()
    elif user_num==6:
        #print('退出系统')
        cho=input('是否要退出系统？是：yes，否：no')
        if( cho=='yes') :break
    else:
        print('输入有误')

lambda表达式:

print(
'''
lambda表达式应用场景： 如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化。
            主要目的：简化内存空间的消耗。
            别称：匿名函数。
                <function <lambda> at 0x000001F6F3C2A318>
                <function fn1 at 0x000001F6F3C2A288>
            参数列表： 可有可无，与函数相同。
            使用格式： lambda x:y x是形参，y是执行语句
'''
)

print(
"""
1.1对比函数与lambda表达式：
"""
)

def fn1():
    return 100
print(fn1) #打印出来的是函数的内存地址
print(fn1()) #打印出来的是函数的返回值

fn2=lambda :111
print(fn2) #打印的是lambda表达式的地址
print(fn2()) #打印的是

print(
'''
几个lambda表达式的实例：
'''
)
#顺序参数
fp=lambda  a,b :a+b
print(fp(3,5))
#默认参数/缺省参数
fp=lambda a,b,c=100:a+b+c
print(fp(100,101))
print(fp(100,101,99))
#可变参数(key_word_arguments)1
fp=lambda *args:args#返回值为元组
print(fp(10))
print(fp(10,20,30))
#可变参数(key_word_arguments)2
fp=lambda **kwargs:kwargs #返回值为字典
print(fp(name='小明',age='15'))
print(fp(name='小x',age='16',gg=6))


print(
    '''
*****带判断的lambda,以及利用lambda进行排序。*****
    '''
)
fp=lambda a,b: a if a>b else b #配合三目运算符使用
print(fp(1000,500))

students=[{'name':'Tina','age':12},
          {'name':'Mike','age':8},
          {'name':'Java','age':22}]
#按照name的值升序排序：
students.sort(key=lambda z:z['name'])
print(students)#sort方法，排序之后，原列表中的次序也改变了
#按照年龄降序排序
students.sort(key=lambda z:z['age'],reverse=True)
print(students)

高阶函数（暂时只有map（））：

print(
    '''
    高阶函数:参数里有函数的函数。。。调用函数时给高阶函数传递低阶函数的名字(又称为函数变量)。
            函数式编程。
    '''
)
'''
前情提示几个函数：
'''
#abs，求绝对值的函数
print(abs(-10))
print(abs(-1.11))
#round,对数字进行四舍五入,
print(round(1.66))
print(round(1.499))
print(round(-1.8))
'''
高阶函数的一个例子
'''
def ab_sum(a,b,f):
    return f(a)+f(b)
t=ab_sum(1,-2,abs) #给自己定义的这个函数传了python内置的函数。
print(t)
'''
Python内置的高阶函数：
        1 map(fun,lst) 参数1，参数2 .
            函数作用于列表中的每一个元素，并返回一个新的列表。
                （也就是说，函数不改变对象，对象自己的方法才改变对象本身）
'''
liebiao=[1,2,3,4,]
def fun(x):
    return x**2#必须要有返回值
# def fun2(x):
#     x=x**2#这样不行，必须要有返回值

lie2=map(fun,liebiao)
print(lie2)#python3打印的是一个列表迭代器类型
print(list(lie2))#转换为列表类型
print(liebiao)

文件操作（打开和关闭文件）：

"""
文件操作的基本步骤:
    打开文件
    操作文件(读,写)
    关闭文件
"""
'''
打开:
    使用open()函数可以打开一个文件或者重新创建一个文件.
'''
f_str='p2.txt' #定义文件名
# r 访问模式: 如果文件不存在,则报错.只读,不能执行写操作.
f=open(f_str,'r')
#f.write('aa')# 该访问模式下只读,不可进行写操作
f.close()
#w 访问模式: 如果文件不存在,则新建文件.写入时会覆盖文件原有内容
#a 访问模式: 如果文件不存在,则新建文件.写入时从文件后面追加内容.

魔法方法之 _init_()（构造方法）:

Python通过调用构造方法来返回该类的对象（无需使用new）。

'''
创建对象的方法：
    变量（引用）=类名（参数，，，） #参数列表可以省略
添加和获取对象属性:
    1.在类的外面添加属性（这一点与java不同）
    2.在类的里面添加属性
'''
# class Washer():#定义了一个洗衣机类
#     def wash(self):
#         print('洗衣服')
#     def info(self):#在类里获取属性
#         print(f'宽度:{self.width} 长度:{self.hight}')
# haier=Washer()
# haier.wash()
# haier.info() #还未添加属性，此时报错
# #在类外添加属性
# haier.width=500
# haier.hight=800
# #在类里获取属性:
# haier.info()
"""
带参数的_init_(),就是带参数的构造函数，在建立对象的时候，就会被自动调用。
"""
class Washer():
    def __init__(self,width,hight):#带参数的_init_(),就是带参数的构造函数
        self.width=width
        self.hight=hight
    def info(self):
        print(f'宽度:{self.width} 长度:{self.hight}')
haier = Washer(10,20)#带参数的_init_(),就是带参数的构造函数
haier.info()

魔法方法之：str( )

'''
1.1     当使用print输出对象的时候，默认打印对象的内存地址。
    但是如果类里定义了_str_方法，那么就会打印从这个方法中
    return 的数据。如果类中没有定义这个方法，那打印的结果
    就是内存地址。
1.2     _str_方法中一般存放类的说明。
'''
class Washer():
    def __init__ (self,width,hight):
        self.width=width
        self.hight=hight
    def __str__(self):
        return '类的解释说明：这是洗衣机的类'
haier=Washer(100,200)
print(haier)#见1.1

继承：

# '''
#     在Python中Object类是所有类的父类。Object类
# 是所有类的基类，顶层类。其他子类叫做派生类。
# '''
# class A():#父类
#     def __init__(self):
#         self.num=1
#     def info_print(self):
#         print(self.num)
# class B(A):#子类
#     pass
# result=B()
# result.info_print()

'''
多继承：一个类同时继承了多个父类。
注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法。
'''
class A():
    def Print(self):
        print('A的方法')
class B():
    def Print(self):
        print('B的方法')
class Child(B,A):
    pass
Demo=Child()
Demo.Print()

'''
子类重写父类同名方法和属性：
    当子类定义了与父类同名的方法和属性之后，再调用这个方法时，调用的将是子类里重写
的方法或者属性。（这是Java里的啥来着？？？,叫重写）
'''
class Child2(Child):
    def Print(self):
        print('Child2的方法')
Demo2=Child2()
Demo2.Print()
#通过: 类名.__mor__的方式，获得类与类之间的继承顺序（mor关系）
print(object.__mro__)#通过打印，可以看出来，返回的是一个元组
print(Child2.__mro__)
"""
子类如何调用父类中的同名方法和属性：
    原因：由于《》，所以想要调用父类的方法和属性
    具体写法：（如果不理解的话，就先记住写法就好了）在要调用父类方法的地方：
            父类.__init__(self)
            父类.方法(self)
            （见下面的代码）
"""
class aa:
    def __init__(self):
        self.way='第一个类'
    def Print(self):
        print(f'这是属于{self.way}')
class bb:
    def __init__(self):
        self.way='第er个类'
    def Print(self):
        print(f'这是属于{self.way}')
class cc(aa,bb):
    def __init__(self):
        self.way='第san个类'
    def Print(self):
        self.__init__()
        print(f'这是属于{self.way}')
    def Print_aa(self):
        aa.__init__(self)
        aa.Print(self)
    def Print_bb(self):
        bb.__init__(self)
        bb.Print(self)
#子类调用同名父类方法测试：
demo=cc()
demo.Print()#调用第三个类的打印
demo.Print_aa()#调用第一个类的打印
demo.Print_bb()#调用第二个类的打印

多层继承（与多继承不是一个概念）

'''
多层继承：A是B的父类，B是C的父类，C是D的父类。（注意与多继承区分）
'''
class aa:
    def __init__(self):
        self.way='第一个类'
    def Print(self):
        print(f'这是属于{self.way}')
class bb(aa):
    def __init__(self):
        self.way='第er个类'
    def Print(self):
        print(f'这是属于{self.way}')
class cc(bb):
    def __init__(self):
        self.way='第san个类'
    def Print(self):
        self.__init__()
        print(f'这是属于{self.way}')
    def Print_Father(self):
        # 实现一次调用多个父类方法
        aa.__init__(self)
        aa.Print(self)
        bb.__init__(self)
        bb.Print(self)
    '''
    实现一次调用多个父类方法 super
    super(当前类名,self).函数()#调用当前类的一个父类(没法调用爷爷类)的写法
    super().函数()
    '''
    # def Print_Father2(self):#有参数super
    #     super(cc,self).__init__()
    #     super(cc, self).Print()
    def Print_Father2(self):#无参数super
        super().__init__()
        super().Print()
demo2=cc()
#demo2.Print_Father() #可见，子类可以调用父类的方法
demo2.Print_Father2()
'''
子类调用父类方法总结：
    1 用 父类.方法()的方式。
    2 用 有参数的super
    3 用 无参数的super   最简洁。
'''

私有：

'''
设置私有的目的：有些方法或者属性不想继承给子类，就将它们设置为私有。
'''
#以下展示如何书写私有属性和方法，以及在继承中的作用
class Father:
    def __init__(self):
        self.__name='dada'#将父亲的姓名设为私有。
        self.money=999999999
        self.power=100000000
    def __custom(self):
        print('吃饭前必须喝粥')#定义私有方法
    def hobby(self):
        print('玩游戏')
    def get_name(self):
        print(self.__name)
    def set_name(self,nme):
        self.__name=nme
class Child(Father):
    name='erzi'#这里是重写吧，重写父类的属性。

xiaoming=Child()
print(xiaoming.name)
print(xiaoming.money)
print(xiaoming.power)
xiaoming.hobby()

'''
私有属性和私有方法只能在类的里面进行使用或者修改。
获取和修改私有属性。
'''
fa=Father()
fa.get_name()
nme='改名了'
fa.set_name(nme)#设置父亲的名字。
fa.get_name()

'''
继承总结：
        子类默认拥有父类的所有属性和方法。
        子类重写父类的方法和属性。
        子类可以调用父类的同名方法和属性。
        super()方法可以快速调用父类方法。
        私有：
            
'''

面向对象三大特征，以及对多态的介绍：

'''
面向对象三大特征：
    封装：
        将属性和方法写到类里的操作即为封装。
        封装可以为属性和方法提供私有权限。
    继承：
        子类默认继承父类的所有属性和方法。
        子类可以重写父类的属性和方法。
    多态：
        传入对象的不同，产生不同的结果。
'''
'''
多态：
    多态指的是一个抽象类有多个子类，多态的概念依赖于继承。
    
    定义：
        多态是一种使用对象的方式，子类重写父类的方法，调用不同对象的
        相同父类方法，可以产生不同的执行结果。
        
    好处：
        调用灵活，有了多态更容易写出通用的代码，做出通用的编程，以适应需求的不断变化。
        
    实现步骤：
        定义父类，并提供公共方法。
        定义子类，并重写父类的方法。
        传递子类对象给调用者，可以看到不同子类执行效果不同。
        
    注意：
        Python中也可以不使用继承来实现多态。
'''

多态：

class dog:
    def work(self):
        print('一只小狗在工作')
class jidu_dog(dog):
    def work(self):
        print('缉毒犬在工作')
class jun_dog(dog):
    def work(self):
        print('军犬在工作')

class Person:
    def work_with_dog(self,dd):#传入不同的狗狗对象，执行不同的方法。
        # 这里我不太明白为什么要传入形参。
        # 而且这个形参还可以随意地变。
        # 写dd可以，dog可以，jun_dog也可以。。。
        # 好晕。
        # 我好像知道了，是因为下面我创建狗狗对象的时候没有加括号。
        # 加了括号之后，这里就可以不需要参数了，
        # 但是如果没有加括号的话，就必须加参数。#dd.work(dd)
        # 为什么呢？？？
        dd.work()

xiaoming=Person()
Jd=jidu_dog()
Jun=jun_dog()
#同一个类中的同一个方法，因为传入的对象不同，打印出来了不同的结果，这就是多态。
xiaoming.work_with_dog(Jd)
xiaoming.work_with_dog(Jun)

类方法和静态方法：

'''
1类属性：
    我的理解：类属性是属于类的。

    1.1设置和访问类属性：
        类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。
        类属性可以使用类对象(类名.属性)或者实例对象（实例.属性）来访问。

    1.2修改类属性：
            类属性只能通过类对象来修改，不能通过实例对象来修改，如果通过实例
        对象来修改类属性，表示的是创建了一个与类属性同名的实例属性。

2类方法和静态方法：

    2.1类方法的特点：
            需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，
        通常我们写为cls。

            注意:cls的作用类似于self，self指的是实例对象，cls指的是类对象。就是这个类。

    2.2类方法使用场景：
            当方法中需要访问类的私有属性时，定义类方法。
            类方法一般和类属性配合使用。
'''

#1.1设置和访问类属性
class Dog():
    tooth=55 #这是一个类属性。
wangcai=Dog()
xiaohei=Dog()
print(Dog.tooth)#用类来访问属性。
print(wangcai.tooth)#用对象来访问属性。
print(xiaohei.tooth)

#修改类属性。
Dog.tooth=88
print(Dog.tooth)#88
print(wangcai.tooth)#88
print(xiaohei.tooth)#88

#不能通过实例对象来修改，如果通过实例对象来修改类属性，表示的是创建了一个与类属性同名的实例属性。
wangcai.tooth=2
print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

class Pig():
    __weight=100 #定义类的私有属性。
    @classmethod
    def get_weight(cls):
        return cls.__weight
    def gett(self):
        return self.__weight

peichi=Pig()
print(peichi.get_weight())
print(peichi.gett())

异常：

'''
异常的语法：
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码
'''
# try:
#     f=open('没有这个文件','r')
#     f.close()
# except:
#     f=open('没有这个文件','w')
#     f.close()
'''
捕获指定异常：

    捕获指定异常的语法：
        try:
            可能发生错误的代码
        except  指定的异常 :
            如果出现异常执行的代码
            
注意：如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
     区分与普通异常的不同。

'''
# try:
#    # print(name) #NameError
#     print(1/0) #不打印
# except NameError:
#     print('有错误')
"""
捕获多个指定异常：
    指定异常的写法：将异常放到一个元组中。
"""
# try:
#    # print(name) #NameError
#     print(1/0) #不打印
# except (NameError,ZeroDivisionError):
#     print('有错误')

'''
捕获异常描述信息：
    见代码。
'''
# try:
#    # print(name) #NameError
#     print(1/0) #不打印
# except (NameError,ZeroDivisionError) as result:#使用as关键字将异常信息保存到变量result里。
#     print(result)#打印异常信息。
'''
捕获所有异常：
    Exception是所有程序异常类的父类。指定异常那里写Exception就可以捕获所有异常了。
'''
# try:
#     print(1/0)
# except Exception as result:
#     print(result)
'''
异常的else:
    当没有异常的时候执行的代码。
'''
# try:
#     print(1)
# except Exception as result:
#     print(result)
# else:
#     print('没有异常的时候执行的代码')
'''
异常的finally:
    无论是否异常都要执行的代码，如：打开文件之后，要关闭文件。
'''
# try:
#     f=open('a.txt','r')
# except Exception as result:
#     f=open('a.txt','w')
# else:
#     print('没有异常的时候执行的代码')
# finally:    #在异常中，文件已经被打开了，所以以后一定要关闭。
#     f.close()


# '''
# 异常的嵌套（传递）：
#
# '''
# import time
# try :
#     f=open('p2.txt')
#     #尝试循环读取内容
#     try:
#         while True:
#             content=f.readline()#按行读取
#             if len(content)==0:
#                 break
#             time.sleep(2)
#             print(content)
#     except:
#         print('程序被意外终止')
# except:
#     print('文件不存在')

'''
自定义异常：
    在python中，抛出自定义异常的语法为raise异常类对象。
'''
class ShortInputErrot(Exception):
    def __init__(self,length,min_len):
        self.length=length #这个self我还是不懂
        self.min_len=min_len
    #设置抛出的异常信息
    def __str__(self):
        return f'你输入的代码长度是：{self.length},最少输入的长度是：{self.min_len}'

def main():
    try:
        content=input('输入密码：')
        if len(content)<=3:
            raise ShortInputErrot(len(content),6) #这是创建的实例还是类实例？忘了。
    except Exception as result:
        print(result)
    else:
        print('密码输入完成')

main()

模块：

'''
模块：
    模块就是一个Python文件。

    1 制作模块的目的：复用代码。比如一个类，除了在当前文件中使用之外，还要在其他
                文件中使用。这时候就可以封装一个模块，在其他文件中导入即可。

    2 测试模块：导入模块的时候，会导入模块中的所有代码。
                应该使用:系统变量__name__==__main__

    3 模块定位顺序：
            顺序：
            注意：由于先查看当前目录，所以如果命名了与自带的模块相同姓名的文件，自带的模块
                    就会报错。
'''

'''
__all__列表：
            当导入列表的时候，只能导入all列表中的内容。
'''

后来的补充

多线程：

创建线程的两种方法：

'''
调用构造器创建进程。
'''

#import threading
# # 定义一个普通的action函数，该函数准备作为线程执行体
# def action(max):
#     for i in range(max):
#         # 调用threading模块current_thread()函数获取当前线程
#         # 线程对象的getName()方法获取当前线程的名字
#         print(threading.current_thread().getName() +  " " + str(i))
# # 下面是主程序（也就是主线程的执行体）
# for i in range(100):
#     # 调用threading模块current_thread()函数获取当前线程
#     print(threading.current_thread().getName() +  " " + str(i))
#     if i == 20:
#         # 创建并启动第一个线程
#         t1 =threading.Thread(target=action,args=(100,))
#         t1.setName('黑天了')
#         t1.start()
#         # 创建并启动第二个线程
#         t2 =threading.Thread(target=action,args=(100,))
#         t2.start()
# print('主线程执行完成!')

'''
继承thread类创建进程
'''

import threading

# 通过继承threading.Thread类来创建线程类
class FkThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self.i = 0
    # 重写run()方法作为线程执行体
    def run(self):
        while self.i < 100:
            # 调用threading模块current_thread()函数获取当前线程
            # 线程对象的getName()方法获取当前线程的名字
            print(threading.current_thread().getName() +  " " + str(self.i))
            self.i += 1
# 下面是主程序（也就是主线程的执行体）
for i in range(100):
    # 调用threading模块current_thread()函数获取当前线程
    print(threading.current_thread().getName() +  " " + str(i))
    if i == 20:
        # 创建并启动第一个线程
        ft1 = FkThread()
        ft1.setName('天黑请闭眼')
        ft1.start()
        # 创建并启动第二个线程
        ft2 = FkThread()
        ft2.start()
print('主线程执行完成!')

self

'''
#对在类中定义的实例方法和构造方法，Python会将第一个参数与调用者自动绑定。
#因此实例在调用以上方法的时候不需要再为第一个参数传值。
# 这个参数一般叫做self，当然，叫别的也可以。

#在类中，不用管成员变量和成员函数的定义顺序，可以自由调用（前面的可以调用后面的）。
#但是，在类中，一个方法调用另一个方法的时候，不可以省略self。

'''
class Dog:
    # 定义一个jump()方法
    def jump(self):
        print("正在执行jump方法")
    # 定义一个run()方法，run()方法需要借助jump()方法
    def run(self):
        # 使用self参数引用调用run()方法的对象
        self.jump()
        print("正在执行run方法")

d = Dog()
d.run()

方法：

PS：类方法和静态方法大多数情况下用不到，因为实例方法的功能就够了。

'''
方法：
    一：类可以调用实例方法，但是在调用的时候必须要显式地为方法传参——sel，因为
类方法调用实例方法不会自动绑定self。
    二：对于动态增加的实例方法，当实例在调用时，也要显示传入参数self。动态增加的实例方法，python不会自动去绑定。
    三：类方法，静态方法
        类方法，静态方法的区别在于：类方法的第一个参数（通常叫做cls）会自动绑定
    到类本身；但是对于静态方法则不会自动绑定。
'''
class Bird:
    # classmethod修饰的方法是类方法
    @classmethod
    def fly (cls):
        print('类方法fly: ', cls)
    # staticmethod修饰的方法是静态方法
    @staticmethod
    def info (p):
        print('静态方法info: ', p)
# 调用类方法，Bird类会自动绑定到第一个参数
Bird.fly()  #①
# 调用静态方法，不会自动绑定，因此程序必须手动绑定第一个参数
Bird.info('crazyit')
# 创建Bird对象
b = Bird()
# 使用对象调用fly()类方法，其实依然还是使用类调用，
# 因此第一个参数依然被自动绑定到Bird类
b.fly()  #②
# 使用对象调用info()静态方法，其实依然还是使用类调用，
# 因此程序必须为第一个参数执行绑定
b.info('fkit')

类变量（还是不是很懂）

class Address :
    detail = '广州'
    post_code = '510660'
    def info (self):
        # 尝试直接访问类变量
#        print(detail) # 报错
        # 通过类来访问类变量
        print(Address.detail) # 输出 广州
        print(Address.post_code) # 输出 510660
# 通过类来访问Address类的类变量
print(Address.detail)
addr = Address()
addr.info()
# 修改Address类的类变量
Address.detail = '佛山'
Address.post_code = '460110'
addr.info()
##########################################

class Record:
    # 定义两个类变量
    item = '鼠标'
    date = '2016-06-16'

    def info(self):
        print('info方法中: ', self.item)
        print('info方法中: ', self.date)


rc = Record()
print(rc.item)  # '鼠标'
print(rc.date)  # '2016-06-16'
rc.info()

# 修改Record类的两个类变量
Record.item = '键盘'
Record.date = '2016-08-18'
# 调用info()方法
rc.info()
##########################################
class Inventory:
    # 定义两个类变量
    item = '鼠标'
    quantity = 2000
    # 定义实例方法
    def change(self, item, quantity):
        # 下面赋值语句不是对类变量赋值，而是定义新的实例变量
        self.item = item
        self.quantity = quantity
# 创建Inventory对象
iv = Inventory()
iv.change('显示器', 500)
# 访问iv的item和quantity实例变量
print(iv.item) # 显示器
print(iv.quantity) # 500
# 访问Inventory的item和quantity类变量
print(Inventory.item) # 鼠标
print(Inventory.quantity) # 2000

Inventory.item = '类变量item'
Inventory.quantity = '类变量quantity'
# 访问iv的item和quantity实例变量
print(iv.item)
print(iv.quantity)

iv.item = '实例变量item'
iv.quantity = '实例变量quantity'
print(Inventory.item)
print(Inventory.quantity)

通过下面这个小例子可以知道：实例变量名和类变量名可以相同，但是二者的修改并不互相影响（两个变量有独立的地址空间，所以是两个变量）。

class demo1:
    a=4#创建了一个类变量a
    def info(self):
        print('instance a=',self.a)
    def info2(self):
        print("demo1.a=",demo1.a)
tt=demo1()
print(tt.a)#4实例变量的值
tt.a=5#创建了一个实例变量，变量名也叫a
tt.info()#instance a= 5
tt.info2()#demo1.a= 4
demo1.a=77
tt.info()#instance a= 5
tt.info2()#demo1.a= 77
#两个变量的地址值不同，所以就不是同一个变量。
print(id(tt.a))#140729448231296
print(id(demo1.a))#140729448233600
#如果没有创建那个实例变量，那实例默认访问的就是类变量，此时:tt.a与demo1.a是同一个变量。

多继承与重写（覆盖，Override）

'''
#override
#子类重写父类的方法。根据下面的代码执行结果，python在调用方法的时候，肯定是
#先看看自己的类里有没有该方法，如果有就不再查询父类里是否有
#这个方法。没有的话，再根据多继承中继承父类的顺序来从前向后
#查询是否有这个方法，有的话就直接调用（多继承里排在前面的优先级高）
'''

# class app:
#     pass
# a=app()
# a.weight=5
# print(id(a.weight))#140729448231296
# a.weight=4
# print(id(a.weight))#140729448231264
# a.weight=77
# print(id(a.weight))#140729448233600

# class Fruit:
#     def info(self):
#         print("我是一个水果！重%g克" % self.weight)
#
# class Food:
#     def taste(self):
#         print("不同食物的口感不同")
#
# # 定义Apple类，继承了Fruit和Food类
# class Apple(Fruit, Food):
#     pass
#
# # 创建Apple对象
# a = Apple()
# a.weight = 5.6
# # 调用Apple对象的info()方法
# a.info()
# # 调用Apple对象的taste()方法
# a.taste()


class Bird:
    # Bird类的fly()方法
    def fly(self):
        print("我在天空里自由自在地飞翔...")


    # 重写Bird类的fly()方法
class Ostrich(Bird):
    def fly(self):
        print("我只能在地上奔跑...")


# 创建Ostrich对象
os = Ostrich()
# 执行Ostrich对象的fly()方法，将输出"我只能在地上奔跑..."
os.fly()

Super（）函数

'''
    Python要求，如果子类重写了父类构造方法，那子类的构造方法必须调用父类的
构造方法。子类的构造方法要调用父类的构造方法有两种方式：
    1. 使用未绑定方法。因为构造方法也是一种实例方法，可以使用：类名.方法(self,,,)来调用。
    2. 使用super()函数调用父类的构造方法。
'''
class Employee :
    def __init__ (self, salary):
        self.salary = salary
    def work (self):
        print('普通员工正在写代码，工资是:', self.salary)
class Customer:
    def __init__ (self, favorite, address):
        self.favorite = favorite
        self.address = address
    def info (self):
        print('我是一个顾客，我的爱好是: %s,地址是%s' % (self.favorite, self.address))
# Manager继承了Employee、Customer
class Manager(Employee, Customer):
    # 重写父类的构造方法
    def __init__(self, salary, favorite, address):
        print('--Manager的构造方法--')
        # 通过super()函数调用父类的构造方法
#        super().__init__(salary)
        # 与上一行代码的效果相同
        super(Manager, self).__init__(salary)
        # 使用未绑定方法调用父类的构造方法
        Customer.__init__(self, favorite, address)
# 创建Manager对象
m = Manager(25000, 'IT产品', '广州')
m.work()  #①
m.info()  #②

多态：

多态就是同一个接口，使用不同的实例而执行不同操作。

class Canvas:
    def draw_pic(self, shape):
        print('--开始绘图--')
        shape.draw(self)

class Rectangle:
    def draw(self, canvas):
        print('在%s上绘制矩形' % canvas)
class Triangle:
    def draw(self, canvas):
        print('在%s上绘制三角形' % canvas)
class Circle:
    def draw(self, canvas):
        print('在%s上绘制圆形' % canvas)
c = Canvas()
# 传入Rectangle参数，绘制矩形
c.draw_pic(Rectangle())
# 传入Triangle参数，绘制三角形
c.draw_pic(Triangle())
# 传入Circle参数，绘制圆形
c.draw_pic(Circle())
print(hasattr(c, 'draw_pic'))
print(hasattr(c.draw_pic, '__call__'))
print(Circle.__dict__)

切片

'''
列表和元组的部分用法：
    1 子序列：[start:end:step]，start位置包含，end的位置不被包含，step是步长。
            如果相对位置：start在左，end在右，step取负数没有意义(任何冲突访问都没有意义)。
            step取正为从左向右遍历，取负为从右向左遍历。
'''
a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
# 访问从第2个到倒数第4个（不包含）所有元素
print(a_tuple[1: 3]) # (20, 5.6)
# 访问从倒数第3个到倒数第1个（不包含）所有元素
print(a_tuple[-3: -1]) # (5.6, 'fkit')
# 访问从第2个到倒数第2个（不包含）所有元素
print(a_tuple[1: -2]) # (20, 5.6)
# 访问从倒数第3个到第5个（不包含）所有元素
print(a_tuple[-3: 4]) # (5.6, 'fkit')


b_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
# 访问从第3个到第9个（不包含）、间隔为2的所有元素
print(b_tuple[2: 8: 2]) # (3, 5, 7)
# 访问从第3个到第9个（不包含）、间隔为3的所有元素
print(b_tuple[2: 8: 3]) # (3, 6)
# 访问从第3个到倒数第2个（不包含）、间隔为3的所有元素
print(b_tuple[2: -2: 2]) # (3, 5, 7)
#逆序输出上面的元组
print(b_tuple[-1:-10:-1])

字典（一点点）

'''
字典：
    1 字典中的key不允许重复。
    2 元组可以作为key但是列表不可作为key
    3 使用字典的时候要先定义（创建，不能直接这样：dict7['数学']=138）
'''

麻达拉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python的笔记

又是持续更新中。。。你哪回更新过。API文档不会查呀字符串：a='a=hello world111'#这种形式的换行符不会被打印，python会认为 \ 后面的也是属于b的#python不是自由格式的语言b='b=hello ' \ 'world222'c='''c=hello world333'''#这种形式的换行符会被打印出来d='''d=hello ...
复制链接

扫一扫