Python入门教程

第一章:基础语法

输出相关:

  • 基本输出案例
    print("HelloWorld")
    # 执行结果:
    '''
    HelloWorld
    '''
  • 转义字符
    # 转义字符"/"
    # 输出前加"r",输出原始字符串,即去除转义字符
    # 输出前加"f",输出填补字符串,和format相似
    name = 'c:\\user'
    x = '路径c:\\user'
    y = r"路径c:\user"
    z = f"路径{name}"
    print(x,"\n",y,"\n",z)
    # 执行结果:
    '''
    路径c:\user 
    路径c:\user 
    路径c:\user
    '''
  • 占位符
    age = 17
    print("我的年龄是:%d岁"%age)
    # 执行结果:
    '''
    我的年龄是:17岁
    '''
  • 间隔符
    print("www", "baidu", "com", sep = ".")
    # 执行结果:
    '''
    www.baidu.com
    '''
  • 控制符
    print("hello", end = "")
    print("world")
    # 执行结果:
    '''
    helloworld
    '''
  • 连接符
    name = "World"
    print("Hello" + name)
    # 执行结果:
    '''
    HelloWorld
    '''
  • 复制符
    count = "num "
    print(count*3)
    # 执行结果:
    '''
    num num num 
    '''
  • 进制转换
    x = 100
    print(bin(x)) #转换为二进制
    print(oct(x)) #转换为八进制
    print(hex(x)) #转换为16进制
    # 执行结果:
    '''
    0b1100100
    0o144
    0x64
    '''
  • 去除指定字符
    a = "abcd"
    print(a.strip("ad")) #去除首尾相同字符
    print(a.replace('bc','-')) #去除整体相同字符
    # 执行结果:
    '''
    bc
    a-d
    '''
  • format
    x = "我是{name},今年{age}".format(name = 'cjl', age = 18)
    print(x)
    # 执行结果:
    '''
    我是cjl,今年18
    '''

输入相关:

  • 基础输入案例
    password = input("请输入密码:")
    print("你输入的密码是:", password)
    print(type(password))
    # 执行结果:
    '''
    请输入密码:666
    你输入的密码是: 666
    <class 'str'>
    '''
  • input默认输入后的类型为字符串
  • 输入后类型强转
    password = int(input("请输入密码:"))
    print("你输入的密码是:", password)
    print(type(password))
    # 执行结果:
    '''
    请输入密码:666
    你输入的密码是: 666
    <class 'int'>
    '''

运算符相关:

算法运算符
  • + 加法
  • - 减法
  • * 乘法
  • / 除法
  • % 取模
  • ** 指数
  • // 整除
比较运算符
  • < 小于
  • > 大于
  • <= 小等
  • >= 大等
  • == 恒等
  • != 不等
身份运算符
  • is 判断两个变量引用对象是否相同
  • is not 判断两个变量引用对象是否不同
    • 用来检测两个变量是否是同一个变量
成员运算符
  • in 包含
  • not in 不包含
    • 用来检测某成员是否是另一个变量的成员
逻辑运算符
  • not 逻辑非,都为假时运行
  • or 逻辑或,一个为真时就运行
  • and 逻辑与,都为真才运行
    • and看做乘法,or看做加法
    • Ture看做1,False看做0
赋值运算符
  • +=x += 1 == x + 1=
  • -=x -= 1 == x - 1=
  • *=x *= 1 == x * 1=
  • /=x /= 1 == x / 1=
  • %=x %= 1 == x % 1=
  • //=x //= 1 == x // 1=
  • **=x **= 1 == x ** 1=
运算符规则
  • 数值运算可能改变结果的数据类型,类型的改变与运算符有关,有如下基本规则:
    • 整数浮点数混合运算,输出结果是浮点数
    • 整数之间运算,产生结果类型与操作符相关,除法运算的结果是浮点数
    • 整数浮点数复数运算,输出结果是复数

第二章:判断和循环

if条件判断:

  • if基本格式

    if 条件1:
     内容
    elif 条件2:
     内容
    else:
     内容
  • 嵌套if格式

    if 条件1:
     if 条件2:
         if 条件3:
             内容
         else:
             内容
     else:
    else:
  • 一行式双分支

    age = int(input("输入年龄:"))
    print("未成年" if age<18 else "成年了")
    '''
    #执行结果:
    输入年龄:18
    成年了
    '''
  • if判断案例-石头剪刀布

import random
print("{0}石头剪刀布游戏{1}".format("*"*10, "*"*10))
print("[0代表:石头]", "[1代表:剪刀]", "[2代表:布]", sep = '\n')
game = ["石头", "剪刀", "布"]
num = input("请输入石头、剪刀、布(0、1、2):")
robot = random.randint(0, 2)
if num.isdigit() and int(num) >= 0 and int(num) <= 2:
    num = int(num)
    print("你出的是'%s',"%game[num], end="")
    if (num == 0 and robot == 1) or (num == 1 and robot == 2) or (num == 2 and robot == 0):
        print("而电脑出的是'%s' — 你赢了!"%game[robot])
    elif num == robot:
        print("而电脑出的也是'%s' — 平局!"%game[robot])
    else:
        print("而电脑出的是'%s' — 你输了!"%game[robot])
else:
    print("<输入有误!>")
# 执行结果:
'''
**********石头剪刀布游戏**********
[0代表:石头]
[1代表:剪刀]
[2代表:布]
请输入石头、剪刀、布(0、1、2):2
你出的是'布',而电脑出的也是'布' — 平局!
'''

for循环:

  • for基本格式

    for 表达式1 in 表达式2:
     内容
  • 嵌套for格式

    for 表达式1 in 表达式2:
     for 表达式1 in 表达式2:
         内容
  • for循环案例-九九乘法表

    for i in range(1, 10):
     for j in range(1, i+1):
         print("%d*%d=%d"%(i, j, i*j), end="\t")
     print("\n")
    # 执行结果:
    '''
    略······
    '''
  • 一行式九九乘法表

    print('\n'.join([' '.join(['%d*%d=%-2d'%(y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)]))

while循环:

  • while基本格式
    while 条件:
     内容
     表达式
  • while实例:
    i = 1
    sum = 0
    while i<=100:
     sum = sum + i
     i += 1
    print(sum)
    # 执行结果:
    '''
    5050
    '''
  • while-else格式
    while 条件:
     内容
     表达式
    else:
     内容
  • while-else实例:
    num = 0
    while num < 3:
     print("num小于3")
     num += 1
    else:
     print("num等于或大于3")
    # 执行结果:
    '''
    num小于3
    num小于3
    num小于3
    num等于或大于3
    '''

循环扩展:

  • break - 结束整个循环体
  • continue - 结束本次循环

第三章:数据类型

字符串相关:

  • 切片
    str = "abcde12345"
    print(str)
    print(str[0])
    print(str[0:5])
    print(str[0:5:2]) #str[起始:结尾:步长]
    # 执行结果:
    '''
    abcde12345
    a
    abcde
    ace
    '''

list(列表):

  • list基本格式

    # 列表名 = [" "," "," "]
    nums = ["a",1,"b"]
  • 遍历列表

    names = ["李华", "小明", "马瑞"]
    for name in names:
     print(name)
    # 执行结果:
    '''
    李华
    小明
    马瑞
    '''
  • a = [1,2]
    b = [3,4]
    #******append******
    a.append(b) #将列表b内的每个元素,看做一个整体追加在列表a的最后面
    print(a)
    #******extend******
    a.extend(b) #将列表b内的每个元素,拆分开逐一追加在列表a的最后面
    print(a)
    #******insert******
    a.insert(1,5)  #将元素5插入到列表a元素下标为1的位置
    print(a)
    #执行结果:
    '''
    [1, 2, [3, 4]]
    [1, 2, [3, 4], 3, 4]
    [1, 5, 2, [3, 4], 3, 4]
    '''
  • nums = ["a","b","c",1,2,3]
    #******del******
    del nums[2] #删除列表nums下标为2的元素
    print(nums)
    #******pop******
    nums.pop()  #删除列表nums最后一个元素
    print(nums)
    #******remove******
    nums.remove("b") #删除指定内容的元素
    print(nums)
    #执行结果:
    '''
    ['a', 'b', 1, 2, 3]
    ['a', 'b', 1, 2]
    ['a', 1, 2]
    '''
  • names = ["张三","李四"]
    print(names)
    names[0] = "小三"
    print(names)
    #执行结果:
    '''
    ['张三', '李四']
    ['小三', '李四']
    '''
  • names = ["张三","李四","张三"]
    name = input("请输入要查的元素:")
    if name in names:
    #index查询的元素有多个时,则输出第一个元素的下标
     print("该元素存在,该元素的下标为:%d"%names.index(name))
    else:
     print("该元素不存在")
    #count查询该元素在列表中出现的次数
    print("该列表存在 %d 个%s"%(names.count(name),names[names.index(name)]))
    #执行结果:
    '''
    请输入要查的元素:张三
    该元素存在,该元素的下标为:0
    该列表存在 2 个张三
    '''
  • 排序

    nums = [1,2,3,6,5,4]
    print(nums)
    #******reverse******
    nums.reverse() #逆序
    print(nums)
    #******sort******
    nums.sort() #升序
    print(nums)
    nums.sort(reverse=True) #降序
    print(nums)
    #执行结果:
    '''
    [1, 2, 3, 6, 5, 4]
    [4, 5, 6, 3, 2, 1]
    [1, 2, 3, 4, 5, 6]
    [6, 5, 4, 3, 2, 1]
    '''
  • 枚举

    nums = ["a","b","c","d"]
    for i,j in enumerate(nums):
     print(i,j)
    #执行结果:
    '''
    0 a
    1 b
    2 c
    3 d
    '''
  • 嵌套列表(二位数组)基本格式

列表名 = [["",""],["",""],["",""]]
print(列表名[外列表下标][内列表下表])
  • list列表实例
products = [["redmi k30",1499],\
            ["redmi k30 pro",2699],\
            ["redmi k30 pro变焦版",2999],\
            ["redmi k30至尊纪念版",1999],\
            ["redmi k30S至尊纪念版",2599],\
            ["手机壳",20],\
            ["钢化膜",10],\
            ["OTG",8]]
print("\n------商品列表------")
#遍历商品列表和价格
for x,phones in enumerate(products):
    print(x+1,"%-20s"%phones[0],"%d元"%phones[1])
print("\n------选购环节------")
#用户自行选购
shopping_cart = []
num = input("请输入需要添加进购物车商品的编号:")
while num != "exit":
    if num.isdigit() and int(num)>0 and int(num)<=len(products):
        shopping_cart.append(products[int(num)-1])
        print("请问还需添加其他商品到购物车吗?")
        print("若需添加请输入对应编号,结账请输入:exit")
        num = input("请输入需要添加进购物车商品的编号:")
    else:
        num = input("该商品不存在,请重新输入:")
else:
    print("\n------结账环节------")
    money = 0
    if len(shopping_cart) != 0:
        print("以下是您购物车内的商品:")
        for shopping in shopping_cart:
            print(shopping[0],":%d元"%shopping[1])
            money = money + shopping[1]
        print("您本次共需支付:%d元"%money)
    else:
        print("购物车空空如也。")
print("******感谢您的光临,下次再见~******")
#执行结果:
'''
------商品列表------
1 redmi k30            14992 redmi k30 pro        26993 redmi k30 pro变焦版     29994 redmi k30至尊纪念版       19995 redmi k30S至尊纪念版      25996 手机壳                  207 钢化膜                  108 OTG                  8------选购环节------
请输入需要添加进购物车商品的编号:5
请问还需添加其他商品到购物车吗?
若需添加请输入对应编号,结账请输入:exit
请输入需要添加进购物车商品的编号:7
请问还需添加其他商品到购物车吗?
若需添加请输入对应编号,结账请输入:exit
请输入需要添加进购物车商品的编号:exit
------结账环节------
以下是您购物车内的商品:
redmi k30S至尊纪念版 :2599元
钢化膜 :10元
您本次共需支付:2609******感谢您的光临,下次再见~******

tuple(元组):

  • tuple基本格式
    #元组名 = (" "," "," ")
    tup = (123,) #单个元素时结尾加逗号
    tup = (1,2,3)
  • 遍历元组
    • 和list列表操作相同
  • 增删改查
    • 增:只能通过连接2个不同的元祖生成一个新元组
    • 删:del 元组名删除整个变量
    • 改:元组元素不支持修改
    • 查:和list列表操作相同

dict(字典):

  • dict基本格式
    #字典名 = {"":"", "":""}
    peoples = {"张三":18, "李四":15}
    #创建空字典
    person = dict()
  • 遍历字典
    peoples = {"张三":18, "李四":15}
    for key,value in peoples.items():
     print(key,value)
    #执行结果:
    '''
    张三 18
    李四 15
    '''
  • peoples = {"张三":18, "李四":15}
    age = input("请输入年龄:")
    peoples["王五"] = age
    print(peoples)
    #执行结果:
    '''
    请输入年龄:17
    {'张三': 18, '李四': 15, '王五': '17'}
    '''
  • peoples = {"张三":18, "李四":15, "王五":17}
    del peoples["张三"] #删除指定的键值对
    peoples.pop("李四") #和del作用相同
    print(peoples)
    peoples.clear()   #清空字典内的内容
    print(peoples)
    del peoples #删除整个字典,删除后不可访问
    #执行结果:
    '''
    {'王五': 17}
    {}
    '''
  • peoples = {"张三":18, "李四":15}
    peoples["张三"] = 17
    print(peoples)
    #执行结果:
    '''
    {'张三': 17, '李四': 15}
    '''
  • peoples = {"张三":18, "李四":15}
    #******keys******
    print(peoples.keys()) #得到所有键
    #******values******
    print(peoples.values()) #得到所有值
    #******items******
    print(peoples.items()) #得到所有键值对
    #******get******
    print(peoples.get("小三","该键不存在")) #查找指定键对应的值
    #执行结果:
    '''
    dict_keys(['张三', '李四'])
    dict_values([18, 15])
    dict_items([('张三', 18), ('李四', 15)])
    该键不存在
    '''
  • 其他操作
    • 合并两个字典:dict1.update(dict2)
    • 把两个列表转换为字典:dict(zip(list1,list2))

set(集合):

  • set基本格式
    #集合名 = {"", "", ""}
    nums = {"a", 1, "b", 2}
  • set独有操作
    s = {1010, "张三", 78, 9}
    t = {1010, "李四", 12.3, 1010}
    print(s - t) # 差集
    print(s & t) # 交集
    print(s ^ t) # 补集
    print(s | t) # 并集
    #执行结果
    '''
    {'张三', 9, 78}
    {1010}
    {'张三', 9, '李四', 12.3, 78}
    {1010, '张三', 9, '李四', 12.3, 78}
    '''

小结对比:

NULL 是否有序 是否可变类型
列表["",""] 有序 可变类型
元祖("","") 有序 不可变类型
字典{"":""} 无序 键不可变,值可变
集合{"",""} 无序 可变类型(不重复)

第四章:函数

函数的定义和调用:

  • 定义函数格式
    #def 函数名(形参):
    #    内容
    def Num(a,b):
     return a+b
    print(Num(5,10))
    #执行结果:
    '''
    15
    '''

函数的参数:

  • 必选参数
    def sum(a,b):
     sum = a+b
     print(sum)
    sum(333,333)
    #执行结果:
    '''
    666
    '''
  • 缺省参数
    def sum(a=333,b=111):
     sum = a+b
     print(sum)
    sum(b=333)
    #执行结果:
    '''
    666
    '''
  • 可选参数

    传入的参数列表为元祖

    def sumCount(*args):
     result = 0
     for item in args:
         result += item
     print(result)
    sumCount(111,222,333)
    #执行结果:
    '''
    666
    '''
  • 关键字参数

    传入的参数列表为字典

    def demo(**dict):
     print(dict)
     pass
    demo(name='cjl', age=18)
    #执行结果:
    '''
    {'name': 'cjl', 'age': 18}
    '''
  • 参数相关案例
    def people(name, age=18, *phone, **contact):
     print("我是{0},今年{1}岁".format(name,age))
     print("我的手机号是:{0}".format(phone))
     print("我的其他联系方式:%s"%contact)
    people("cjl","19",12345,54321,qq="2653644677",wechat="chen2653644677")
    #执行结果:
    '''
    我是cjl,今年19岁
    我的手机号是:(12345, 54321)
    我的其他联系方式:{'qq': '2653644677', 'wechat': 'chen2653644677'}
    '''

参数的引用:

  1. 在python当中万物皆对象,在函数调用的时候,实参传递的就是对象的引用
  2. 了解了原理之后,就可以更好的去把控在函数内部的处理是否会影响到函数外部的数据变化
  • 参数传递是通过对象引用来完成的
    li=[]
    def test(parms):
     li.append([1,2,3])
     print(id(parms))
     print("内部的{}".format(parms))
    print(id(li))
    test(li)
    print("外部的{}".format(li))
    #执行结果:
    '''
    2712787529992
    2712787529992
    内部的[[1, 2, 3]]
    外部的[[1, 2, 3]]
    '''

函数返回值:

  • return
    def fun(a,b):
     sum = a + b
     return sum, sum * a
    rs1,rs2 = fun(10,10)
    print('rs1={0},rs2={1}'.format(rs1,rs2))
    #执行结果:
    '''
    rs1=20,rs2=200
    '''

函数的嵌套:

  • 从上向下执行
    def fun1():
     print("666")
    def fun2():
     print("xxxxxx")
     fun1()
     print("xxxxxx")
    fun2()
    #执行结果:
    '''
    xxxxxx
    666
    xxxxxx
    '''

变量作用域:

  • 局部变量
    def text1():
     a = 123
     print("修改前:%d"%a)
     a = 666
     print("修改后:%d"%a)
    def text2():
     a = 888
     print("text2的a值和text1中的a值不冲突--%d"%a)
    text1()
    text2()
    #执行结果:
    '''
    修改前:123
    修改后:666
    text2的a值和text1中的a值不冲突--888
    '''
  • 全局变量
    a = 666  #全局变量
    def text1():
     print(a) #调用全局变量a
    def text2():
     print(a) #调用全局变量a
    text1()
    text2()
    #执行结果:
    '''
    666
    666
    '''
  • 局部、全局变量名相同时
    a = 100  #全局变量a
    def text1():
     a = 123 #局部变量a和全局变量同名时,局部优先
     print("修改前:%d"%a)
     a = 666
     print("修改后:%d"%a)
    def text2():
     print("a的值为:%d"%a) #没有局部变量,默认调用全局变量
    def text3():
     global a #声明全局变量在函数中的标识符
     a = 200
     print("使用global修改全局变量后:%d"%a)
    text1()
    text2()
    text3()
    #执行结果:
    '''
    修改前:123
    修改后:666
    a的值为:100
    使用global修改全局变量后:200
    '''

匿名函数:

  • lambda表达式
    rs1 = lambda x,y: x if x>y else y
    rs2 = (la4mbda x,y: x if x>y else y)(10,5)
    print(rs1(10,5))
    print(rs2)
    #执行结果:
    '''
    10
    10
    '''

递归函数

  • 函数自己调用自己
    def digui(n):
     if n == 1:
         return 1
     else:
         return n*digui(n-1)
    print(digui(5))
    #执行结果:
    '''
    120
    '''

内置函数:

  • cmp(a,b)

    • 用于判断a和b的大小关系,a<b返回-1a==b返回0a>b返回1
  • eval('')

    • 用来执行一个字符串表达式,并返回表达式的值
    • a,b = 10, 6
      print(eval('a*b + pow(b,2) - 66'))
      # 30
  • all(xxx)

    • 如果参数列表中含有False、0则返回False,否则返回True
    • li=[0,1,2]
      print(all(li))
      # False
  • any(xxx)

    • 如果参数列表都为False、空、0则返回False,否则返回True
    • li=[0,1,2]
      print(any(li))
      # True
  • xxx.sort()

    • 仅对list列表进行排序操作,直接修改原始对象,默认为升序
    • 参数:
      • key=len:按字符串长度排序
      • key=str.lower:忽略大小写排序
      • reverse=True:更改为降序
  • sorted(xxx)

    • 所有可迭代的对象进行排序操作,不改变原来的对象,而是返回一个新的列表,参数reverse=True时排序顺序为降序
  • zip(xx,xx,...)

    • 把序列中对应的索引位置的元素,储存为一个元祖,可强转为list列表输出
    • li=['a','b','c']
      ls=['我','你','他']
      print(list(zip(li,ls)))
      # [('a', '我'), ('b', '你'), ('c', '他')]
  • enumerate()

    • 返回一个枚举对象,用于将一个可遍历的数据对象(如:列表、元祖、字符串)组合为一个索引序列
    • li=['你','真','菜']
      for item in enumerate(li,1):
          print(item,end=' ')
      # (1, '你') (2, '真') (3, '菜') 
  • hasattr(x,x)

    • 用于判断对象是否包含对应的属性
    • class hasattrDemo:
      a = 1
      demo = hasattrDemo()
      print(hasattr(demo,'a'),hasattr(demo,'b'))
      # True False
  • isinstance(a,b)

    • 用于判断a是否是b类型,类似于type()
  • vars()

    • 用于返回对象的属性和属性值的字典对象
  • map()

    • 据提供的函数对指定序列做映射
    • def square(x):
          return x ** 2
      res = list(map(square, [1,2,3,4,5]))
      print(res)
      # 使用lambda匿名函数
      # print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])))
      # 执行结果:
      '''
      [1, 4, 9, 16, 25]
      '''
    • 对字典
    • L = ["1","2","3","4","5"]
      def func(key):
          dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6}
          return dic[key]
      res = list(map(func, L))
      print(res)
      # 执行结果:
      '''
      [1, 2, 3, 4, 5]
      '''
  • reduce()

    • 对参数序列中元素进行累积
    • from functools import reduce
      L = [1,2,3,4,5]
      def func(x,y):
          return x*10 + y
      res = reduce(func,L)
      print(type(res), res)
      # 执行结果:
      '''
      <class 'int'> 12345
      '''
  • iter():返回一个迭代器

    • next():获取迭代器中下一个元素
    • lis = [i for i in range(1,3)]
      print(lis)
      ite = iter(lis)
      print(ite)
      print(next(ite))
      print(next(ite))
      #执行结果:
      [1, 2]
      <list_iterator object at 0x000002515BCE5370>
      1
      2

第五章:面向对象(上)

类和对象:

  • 定义类:class 类名():

五种下划线:

  • _:用于临时或无意义变量的名称
  • _xxx:命名约定,说明该属性或方法仅供内部使用,但解释器不会强制执行
  • xxx_:避免声明的变量和关键字冲突
  • __xxx:用于声明属性和方法的私有化,解释权强制执行
  • __xxx__:Python自带的魔术方法,应避免自己声明该命名方式

__init__构造函数:

  • python自带的内置函数具有特殊的函数,使用双下划线包起来的【魔术方法】
  • 是一个初始化的方法用来定义实例属性和初始化数据的,在创建对象的时候自动调用,不用手动去调用
  • 利用传参的机制可以让我们定义功能更加强大并且方便的类
    class People():
     def __init__(self,name,age):
         self.name = name
         self.age = age
    cjl = People('陈家霖',18)
    print('我是{0}今年{1}岁'.format(cjl.name, cjl.age))
    #执行结果:
    '''
    我是陈家霖今年18岁
    '''
  • self指的是类实例对象本身,相当于java的this

魔术方法:

  • __str__:在将对象转换成字符串,相当于java的toString

    class People():
     def __init__(self,name,age):
         self.name = name
         self.age = age
     def __str__(self):
         return '我是{0}今年{1}岁'.format(self.name, self.age)
    cjl = People('陈家霖',18)
    print(cjl)
    #执行结果:
    '''
    我是陈家霖今年18岁
    '''
  • __new__:优先 __init__初始化方法被调用,第一个参数默认为cls

    class Person(object):
     def __init__(self, name, age):
         print('执行__init__')
         self.name = name
         self.age = age
     def __new__(cls, name, age):
         print('执行__new__')
         return super(Person, cls).__new__(cls)
     def __str__(self):
         return '<Person: %s(%s)>'%(self.name, self.age)
    cjl = Person('cjl', 18)
    print(cjl)
    #执行结果:
    '''
    执行__new__
    执行__init__
    <Person: cjl(18)>
    '''
  • __mro__:用于显示类的继承关系

    class D():
     def play(self):
         print("'D'类的play")
    class C(D):
     def play(self):
         print("'C'类的play")
    class B(D):
     pass
    class A(B,C):
     pass
    demo = A()
    demo.play()
    print(A.__mro__)
    #执行结果:
    '''
    'D'类的play
    (<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)
    '''
  • __dict__:用于查看类的所有属性,以字典形式显示

    class People():
     def __init__(self,name,age):
         self.name = name
         self.age = age
    cjl = People('cjl',18)
    print(cjl.__dict__)
    #执行结果:
    '''
    {'name': 'cjl', 'age': 18}
    '''

析构方法:

  • __del__:和__init__一样自动执行,用于释放对象实现资源回收,当一个对象调用后,自动执行清理该对象;也可使用del 对象名手动清理
class People():
    def __init__(self,name):
        self.name = name
        print("我是 %s 执行构造方法"%name)
    def __del__(self):
        print("执行析构方法,回收对象")
cjl = People("cjl")
print("--------使用手动清理--------")
del cjl  # 手动清理
print(cjl)
#执行结果:
'''
我是 cjl 执行构造方法
--------使用手动清理--------
执行析构方法,回收对象
NameError: name 'cjl' is not defined
'''

继承:

  • 单继承:一个子类继承一个父类(找亲爹)

    class Person():
     def __init__(self, name, age):
         self.name = name
         self.age = age
     def eat(self):
         print('吃饭...')
    class Men(Person):
     def __init__(self, name, age, height):
         super().__init__(name,age)
         self.height = height
     def play(self):
         print('玩儿...')
     def __str__(self):
         return '我是{}今年{}岁,身高{}'.format(self.name,self.age,self.height)
    cjl = Men('cjl',18,183)
    print(cjl, '\n调用父类方法:')
    cjl.eat()
    #执行结果:
    '''
    我是cjl今年18岁,身高183 
    调用父类方法:
    吃饭...
    '''
  • 多继承:一个子类继承多个父类(认干爹)

    class A():
     def a(self):
         print("A:我是C类它祖先类")
     pass
    class B(A):
     def b(self):
         print("B:我是C类它父类")
     pass
    class C(B):
     pass
    num = C()
    num.a()
    num.b()
    print(C.__mro__)
    #执行结果:
    '''
    A:我是C类它祖先类
    B:我是C类它父类
    (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
    '''

重写:

  • 所谓重写,就是在子类中有一个和父类一模一样的方法,即子类的方法会覆盖父类的方法
    class Dog():
     def __init__(self,name,color):
         self.name = name
         self.color = color
     def bark(self):
         print("父类:汪汪汪的叫...")
    class HaShiQi(Dog):
     def __str__(self):
         return '这一只 {0} 的狗叫 {1} '.format(self.color,self.name)
     def bark(self):
         # 重写父类方法
         print("子类:嗷嗷嗷的叫...")
    hsq = HaShiQi('哈士奇','白色')
    print(hsq)
    hsq.bark()
    #执行结果:
    '''
    这一只 白色 的狗叫 哈士奇 
    子类:嗷嗷嗷的叫...
    '''

多态:

  • 多态的实现需要遵循两个条件:
    • 继承、多态发生在父类和子类之间
    • 重写、子类重写父类的方法
      class Animals:
      def say_hello(self):
       print("我是一只小动物...")
      class People:
      def say_hello(self):
       print("我是人...")
      class Pig(Animals):
      def say_hello(self):
       print("我是可爱的小猪.")
      class Cat(Animals):
      def say_hello(self):
       print("我是呆萌的小猫.")
      class Dog(Animals):
      def say_hello(self):
       print("我是忠诚的小狗.")
      class Student(People):
      def say_hello(self):
       print("我是三年级的小朋友.")
      def commonInvoke(obj):
      obj.say_hello()
      listObj = [Pig(),Cat(),Dog(),Student()]
      for item in listObj:
      commonInvoke(item)
      #执行结果:
      '''
      我是可爱的小猪.
      我是呆萌的小猫.
      我是忠诚的小狗.
      我是三年级的小朋友.
      '''

类属性和实例属性:

  • 类属性是可以被类对象和实例对象共同访问使用的
  • 实例属性只能由实例对象所访问
class Person:
    age = 18
    def __init__(self,name):
        self.name = name
cjl = Person('cjl')
print(cjl.name)
print(Person.name)
#执行结果:
'''
实例对象: 18 cjl
类对象: 18
AttributeError: type object 'Person' has no attribute 'name'
'''

类方法和静态方法:

  • 类方法用@classmethod来修饰,类方法的第一个参数对象是cls,虽然也能通过实例访问,但不推荐这样调用
class Person:
    people = 'cjl'
    @classmethod
    def get_name(cls):
        return cls.people
    @classmethod
    def change_name(cls,name):
        cls.people = name
print('类方法调用:%s'%(Person.get_name()))
p = Person()
print('实例对象调用(不推荐):%s'%(p.get_name()))
print('--------------修改之后----------------')
Person.change_name('lxl')
print(Person.get_name())
#执行结果:
'''
类方法调用:cjl
实例对象调用(不推荐):cjl
--------------修改之后----------------
lxl
'''
  • 静态方法用@staticmethod来修饰,静态方法可以不带参数,使用类和实例均可调用
import time
class TimeText:
    @staticmethod
    def time():
        return time.strftime('%H:%M:%S',time.localtime())
print('类对象调用:',TimeText.time())
demo = TimeText()
print('实例对象调用:',demo.time())
#执行结果:
'''
类对象调用: 09:44:47
实例对象调用: 09:44:47
'''

第六章:面向对象(下)

私有化属性:

  • 在属性前加__,私有化后在外部不能调用,子类不能继承
    class Person:
     def __init__(self):
         self.__name = 'cjl'
         self.age = 18
     def __str__(self):
         return '我是{0}今年{1}岁了'.format(self.__name, self.age)
    class Men(Person):
     def printInfo(self):
         # 无法继承父类的私有化属性
    #         print(self.name)
         print(self.age)
    p = Person()
    print(p)
    # 无法在外部访问私有化属性
    # print(p.__name)
    men = Men()
    men.printInfo()
    #执行结果:
    '''
    我是cjl今年18岁了
    子类继承父类: 18
    '''
  • 私有化方法:
    • 和私有化属性一样,在方法前加__,私有化后在外部不能调用,子类不能继承

property属性函数:

  • 使用property属性函数,用于调用和修改私有化属性
    class Person:
     def __init__(self):
         self.__age = 18
     def get_age(self):
         return self.__age
     def set_age(self,age):
         if age < 0:
             print("年龄有误")
         else:
             self.__age = age
     age = property(get_age,set_age)
    cjl = Person()
    cjl.age = 19
    print('修改后的年龄:',cjl.age)
    #执行结果:
    '''
    修改后的年龄: 19
    '''

装饰器:

  • 用于调用和修改私有属性,用关键字@property@xxx.setter进行装饰,推荐使用该方法
    class Person:
     def __init__(self):
         self.__age = 18
     @property
     def age(self):
         return self.__age
     @age.setter
     def age(self,age):
         if age < 0:
             print("年龄有误")
         else:
             self.__age = age
    cjl = Person()
    cjl.age = 19
    print('修改后的年龄:',cjl.age)
    #执行结果:
    '''
    修改后的年龄:19
    '''

单例模式:

  • 确保一个类只有一个实例的存在(类似win系统的回收站)

  • 实现方式一:通过类属性保存初次创建的实例对象,如果存在就返回保存的,没有就创建新的实例对象

    class DataBase(object):
     _instance = None
     def __init__(self, name, age):
         print(name, age)
     def __new__(cls, *args, **kwargs):
         if not cls._instance:
             cls._instance=super(DataBase,cls).__new__(cls)
         return cls._instance
    db1 = DataBase('cjl',18)
    print(id(db1))
    db2 = DataBase('lxl',15)
    print(id(db2))
    #执行结果:
    '''
    cjl 18
    2488840593520
    lxl 15
    2488840593520
    '''
  • 实现方式二:只执行一次init方法,通过类变量进行标记控制

    class Demo(object):
     __instance = None
     __isinit = True
     def __init__(self, name, age):
         if Demo.__isinit:
             self.name = name
             self.age = age
             __isinit = False
     def __new__(cls, *args, **kwargs):
         if not cls.__instance:
             cls.__instance=super(Demo,cls).__new__(cls)
             return cls.__instance
         else:
             return cls.__instance
    d1 = Demo('cjl',18)
    print(id(d1), d1.name,d1.age)
    d2 = Demo('lxl',15)
    print(id(d2), d2.name,d2.age)
    #执行结果:
    '''
    2488816354400 cjl 18
    2488816354400 lxl 15
    '''

动态绑定属性方法:

  • 动态添加类属性、方法属性
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '{}今年{}岁了'.format(self.name,self.age)
cjl = People('cjl',18)
People.sex = '男'
print(cjl)
print("动态添加类属性:性别,",cjl.sex)
#执行结果:
'''
cjl今年18岁了
动态添加类属性:性别, 男
'''
  • 动态绑定类方法
import types
def textMothend(self):
    print('{}今年{}岁了,性别:{}'.format(self.name,self.age,self.sex))
@classmethod
def classmethodTest(cls):
    print("类方法...")
@staticmethod
def staticmethodTest():
    print("静态方法...")
class People:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '{}今年{}岁了'.format(self.name,self.age)
cjl = People('cjl',18)
People.sex = '男'
print(cjl)
print("动态添加类属性:性别 -",cjl.sex)
cjl.printInfo = types.MethodType(textMothend,cjl) #动态绑定方法
print("---------------动态绑定后-------------")
cjl.printInfo()
#绑定类方法 
People.TestMethod = classmethodTest
print("通过类调用:",end='\t\t')
People.TestMethod()
print("通过实例对象调用:",end='\t')
cjl.TestMethod()
#绑定静态方法 
People.TestMethod = staticmethodTest
print("通过类调用:",end='\t\t')
People.TestMethod()
print("通过实例对象调用:",end='\t')
cjl.TestMethod()
#执行结果:
'''
cjl今年18岁了
动态添加类属性:性别 - 男
---------------动态绑定后-------------
cjl今年18岁了,性别:男
通过类调用:        类方法...
通过实例对象调用:    类方法...
通过类调用:        静态方法...
通过实例对象调用:    静态方法...
'''

__slots__:

  • __slots__ = ():后跟元组,类型是字符串
    • 限制实例添加的属性,括号内为空时,则不允许添加任何属性;
    • 节省空间,使用后则类属性不会被存放在__dict__内,所以无法使用__dict__访问全部类属性;
    • 继承时子类不受影响,但如果子类也声明该方法时,则也会继承父类的属性限制
      class Person(object):
      # 添加属性限制
      __slots__ = ('name','age','sex')
      def __init__(self):
       pass
      def __str__(self):
       return '{}........{}'.format(self.name,self.age)
      class Men(Person):
      __slots__ = ('school')
      def __init__(self):
       pass
      def __str__(self):
       return '{}....{}....{}'.format(self.name,self.school,self.age)
      pass
      cjl = Person()
      cjl.name = 'cjl'
      cjl.age = 18
      # cjl.school = 'sqxy' # 未在属性限制范围内,所以报错
      print(cjl)
      cjl.sex = '男'
      lxl = Men()
      lxl.name = 'lxl'
      lxl.age = 15
      lxl.school = '七中'
      print(lxl)
      #执行结果:
      '''
      cjl........18
      lxl....七中....15
      '''

第七章:文件操作

读写文件:

  • 常用访问模式

    • r:以只读方式打开(默认模式)
    • w:用于写入,如果文件存在会将其覆盖,不存在则会创建
    • a:用于写入,如果文件存在会在其后追加内容,不存在则会创建
    • rb:以二进制的只读方式打开
    • wb:以二进制的写入模式打开
    • +:打开一个文件进行更新(可读可写)
    • 注: 路径中由于\是转义符,所以表示路径时,使用\\/或路径前加r
  • encoding='utf-8'设置文件编码

  • 基本格式

    #变量名 = open("文件名","访问模式")
    #文件名.close()
    txt = open(r'路径', 'r')
    print(txt.read())
    txt.close()
    # 推荐使用with格式,with格式:
    # with open("文件名",'访问模式') as 别名:
    with open(r'路径', 'r') as txt:
     print(txt.read())
  • .readline():从文件中读入一行内容

  • .readlines():从文件中读入所有行,以每行为元素形成一个列表

  • .write():单行写入,将一个字符串写入文件

  • .writelines():直接将列表类型的各元素连接起来并写入

  • .tell():文件定位,获取当前文件指针读取到的位置

  • .truncate(x):截取输出前x个字符

  • .seek(x,y):改变当前文件操作指针的位置,x的值为偏移量单位字节,y的值(0: 文件开头; 1: 当前位置; 2: 文件结尾)

  • 文件操作实例:

    # 文件备份
    def fileCopy():
     try:
         # 接收用户输入的文件名
         old_file = input("请输入需要备份的文件名:")
         file_list = old_file.split('.')
         # 构造新的文件名
         new_file = file_list[0] + '_备份.' + file_list[1]
         old_f = open(old_file, 'rb')
         new_f = open(new_file, 'wb')
         content = old_f.read()
         new_f.write(content)
     except Exception as result:
         print("你输入的文件名不存在.", result)
     else:
         old_f.close()
         new_f.close()
         print(new_file,"文件备份完成.")
    fileCopy()
    #执行结果:
    '''
    请输入需要备份的文件名:text.txt
    text_备份.txt 文件备份完成.
    '''

遍历文件:

  • 从文本文件中逐行读入内容并进行处理是一个基本的文件操作需求。文本文件可以看成是由行组成的组合类型,因此,可以使用遍历循环逐行遍历文件。
    with open('路径', 'r') as txt:
     print(txt.readlines())
     for x in txt:
         print(x)

操作文件:

  • 文件重命名
    import os
    os.rename("原名称", "新名称")
  • 删除文件
    import os
    os.remove("文件名")
  • 获取当前目录
    import os
    os.getcwd()
  • 改变默认目录
    import os
    os.chdir("路径")
  • 遍历目录列表
    import os
    with os.scandir('d:/') as scan:
     for s in scan:
         print(s.name)
  • 遍历目录文件
    import os
    basePath = 'd:/'
    for s in os.scandir(basePath):
     if os.path.isfile(os.path.join(basePath,s))
         print(s)
  • 创建文件夹
    import os
    os.mkdir("文件夹名")
  • 删除文件夹
    import os
    os.redir("文件夹名")

第八章:错误与异常

常见的异常类型:

  • Exception:代表所有异常类型
  • AssertError:断言语句(assert)失败
  • AttributeError:尝试访问未知的对象属性
  • EOFError:用户输入文件末尾标志EOF(Ctrl+d)
  • FloatingPointError:浮点计算错误
  • GeneratorExit:generator.close()方法被调用的时候
  • ImportError:导入模块失败的时候
  • IndexError:索引超出序列的范围
  • KeyError:字典中查找一个不存在的关键字
  • KeyboardInterrupt:用户输入中断键(Ctrl+c)
  • MemoryError:内存溢出(可通过删除对象释放内存)
  • NameError:尝试访问一个不存在的变量
  • NotImplementedError:尚未实现的方法
  • oSError:操作系统产生的异常(例如打开一个不存在的文件)
  • OverflowError:数值运算超出最大限制
  • ReferenceError:弱引用(weak reference)试图访问一个已经被垃圾回收机制回收了的对象
  • RuntimeError:一般的运行时错误
  • StopIteration:迭代器没有更多的值
  • SyntaxError:Python的语法错误
  • IndentationError:缩进错误
  • TabError:Tab和空格混合使用
  • SystemError:Python编译器系统错误
  • SystemExit:Python编译器进程被关闭
  • TypeError:不同类型间的无效操作
  • UnboundLocalError:访问一个未初始化的本地变量(NameError的子类)
  • UnicodeError:Unicode相关的错误(ValueError的子类)
  • UnicodeEncodeError:Unicode编码时的错误(UnicodeError的子类)
  • UnicodeDecodeError:Unicode解码时的错误(UnicodeError的子类)
  • UnicodeTranslateError:Unicode转换时的错误(UnicodeError的子类)
  • ValueError:传入无效的参数
  • ZeroDivisionError:除数为零

基本格式:

try:
   - 尝试实现某个操作,
   - 如果没出现异常,任务就可以完成
   - 如果出现异常,将异常从当前代码块扔出去尝试解决异常
except 异常类型:
   - 解决方案: 用于尝试在此处处理异常解决问题
except (异常类型1, 异常类型2...):
   - 解决方案: 针对多个异常使用相同的处理方式
excpet Exception:
   - 解决方案: 所有异常的解决方案
else:
   - 如果没有出现任何异常,将会执行此处代码
finally:
   - 无论有没有异常都要执行的代码

异常实例:

import time
try:
    f = open("test1.text","r")
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    finally:
        f.close()
        print("文件关闭")
except Exception as result:
    print("发生异常···")
#执行结果:
'''
发生异常···
'''

手动引发异常:

  • 使用raise关键字实现手动引发异常
try:
    print("我是cjl")
    #手动引发一个异常,注意语法:raise ErrorClassName
    raise ValueError
    print("还没完呀")
except NameError as e:
    print("NameError")
except ValueError as e:
    print ("ValueError")
except Exception as e:
    print("有异常")
finally:
    print("我肯定会被执行")
#执行结果:
'''
我是cjl
ValueError
我肯定会被执行
'''

自定义异常:

class TextException(Exception):
    def __init__(self,leng):
        self.len = leng
    def __str__(self):
        return '你输入的数据长度是:' + str(self.len) + ',超过长度了.'
class TextDemo():
    name = input('请输入数据:')
    try:
        if len(name) > 5:
            raise TextException(len(name))
        else:
            print(name)
    except TextException as result:
        print(result)
    finally:
        print("执行完毕.")
TextDemo()
#执行结果:
'''
请输入数据:gfhsuidgoashuidghasu
你输入的数据长度是:20,超过长度了.
执行完毕.
'''

文章作者:Torres-圣君
文章链接:https://www.cjlblog.vip/posts/b8a3dfda.html
版权声明:本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 Torres-圣君


  转载请注明: Torres-圣君 Python入门教程

评论
  目录