python基础

最新推荐文章于 2022-07-12 09:55:14 发布
最新推荐文章于 2022-07-12 09:55:14 发布
阅读量833 收藏
点赞数 1
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jin_xinyu/article/details/124326728
版权

python知识点

  • eval(str)：字符串表达式求值

  • bin(n)  # 二进制
oct(n)  # 八进制
hex(n)  # 十六进制

  • re.sub('[a-z,A-Z]', ' ', str)  # 去掉a-z和A-Z之间所有字符

  • 凸多边形面积

    import numpy as np
n = int(input())
list_coordinate = []  # 储存坐标
while n:  # 输入坐标
    list_coordinate.append(list(map(int, input().split())))
    n -= 1
list_dot = []  # 储存点
for i in range(len(list_coordinate)):
    list_dot.append(np.array(list_coordinate[i]))
list_vector = []  # 储存向量--类似：1-2 1-3 1-4 1-n
for i in range(1, len(list_dot)):
    list_vector.append(list_dot[0] - list_dot[i])  # 计算向量
list_triangle = []  # 储存三角形面积
for i in range(len(list_vector) - 1):
    t = np.cross(list_vector[i], list_vector[i + 1])  # 计算叉乘的模
    list_triangle.append(float(np.linalg.norm(t)/2))  # 储存面积
t = sum(list_triangle)
print('%.2f' % t)

  • set(list1) < set(list2) :判断 l1 列表是否在 l2 列表中

  • set(list1) & set(list2) : l1 与 l2 的交集

  • set(list1) | set(list2)：l1 与 l2 的并集

  • set(list1) - set(list2) ： l1 与 l2 的差集

  • str.zfill(n) : str 按 n 位数字输出，在前面补 0

  • 分数运算：

    from fractions import Fraction
t = Fraction(1, 2) * 2
a = Fraction(1, 2) * Fraction(1, 2)

  • 列出所有组合：导入库 import itertools，

    for i in itertools.permutations(list_str, n):
    print(i)
    
'''
product 笛卡尔积　　（有放回抽样排列）

permutations 排列　　（不放回抽样排列）

combinations 组合,没有重复　　（不放回抽样组合）

combinations_with_replacement 组合,有重复　　（有放回抽样组合）
'''

    list_str 列表里面是字符串， n 是每个排列的大小， 是以元组形式输出，即 i 是元组

  • print('%.4f' % n)  # 格式化输出

  • 函数说明

    def compare(a, b):
    """比较"""
    if a > b:
        return a
    else:
        return b

  • 二维数组定义

# 该列表里面值为1
list_def = [[0 for low in range(4)] for row in range(5)]

  • print(id(a)) # 查看内存地址 id()

  • 修改全局变量值： global

  • 函数返回元组，可以省略括号

  • 交换两个变量： a, b = b, a

  • 缺省参数（默认值），函数中定义时，参数要放在最后

    def isnnu(title, g = Ture):

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PM0b3sMg-1650532250751)(C:\Users\15751083927\AppData\Roaming\Typora\typora-user-images\image-20220418211256525.png)]

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qlQB9opJ-1650532250753)(C:\Users\15751083927\AppData\Roaming\Typora\typora-user-images\image-20220418212203689.png)]

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Sl2p02A-1650532250754)(C:\Users\15751083927\AppData\Roaming\Typora\typora-user-images\image-20220418211542264.png)]

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g4n7eRij-1650532250755)(C:\Users\15751083927\AppData\Roaming\Typora\typora-user-images\image-20220418212108314.png)]

os模块

import os

print(os.name)  # 给出操作系统的名字，如Windows 返回 'nt'; Linux 返回'posix'

print(os.getcwd())  # 全称应该是'get current work directory'，获取当前工作的目录

path1 = r'D:\PyCharmProject'
print(os.listdir(path1))  # 列出path目录下所有的文件和目录名,以列表的形式全部列举出来，其中没有区分目录和文件

path = ''
os.remove(path)  # 删除path指定的文件

os.rmdir(path)  # 删除path指定的目录

os.mkdir(path)  # 创建path指定的目录,这样只能建立一层，要想递归建立可用：os.makedirs()

os.path.isfile(path)  # 判断指定对象是否为文件。是返回True,否则False

os.path.isdir(path)  # 判断指定对象是否为目录。是True,否则False

os.path.exists(path)  # 检验指定的对象是否存在。是True,否则False.

os.path.split(path)  # 返回路径的目录和文件名，即将目录和文件名分开，而不是一个整体。此处只是把前后两部分分开而已。就是找最后一个'/'

os.system(cmd)  # 执行shell命令。返回值是脚本的退出状态码，0 代表成功，1 代表不成功

os.chdir(path)  # 'change dir'改变目录到指定目录

os.path.getsize(文件)  # 获得文件的大小，如果为目录，返回0

os.path.abspath(文件)  # 获得绝对路径。

os.path.join(path, name)  # 连接目录和文件名，与 os.path.split(path)相对。

os.path.basename(path)  # 返回文件名

os.path.dirname(path)  # 返回文件路径

random

import random

print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数

a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)

导入自定义工具包

import myself

n = int(input())
myself.multi(n)  # myself.(功能)

列表

  • list_a.insert(1, 2)  # 第1个位置插入2（从 0 开始）
n = list_a.index(1)  # 索引 1 在列表中的位置（从1开始）
t = list_a.copy()  # 复制列表
list_a.remove(1)  # 删去索引到第一个值 1
list_a.pop()  # 删去最后一个数
list_a.count(1)  # 1 在列表中出现的次数
del list_a[1]  # 从内存中删去列表 1 位置的数据
a = len(list_a)  # 列表中的元素个=总数
list_a.extend(list_def)  # 将列表 list_def的内容 插入到 list_a 后面

元组

  • 函数的参数和返回值，一个函数可以接收多个参数或者一次返回多个数据

  • 格式字符串，格式化字符串后面的（）本质上就是一个元组

  • 列表不可以被修改，可以保护数据安全

# 和列表很像
tup = tuple(input().split(' '))
print(tup[0])  # 输出第一个位置
print(tup.count('1'))  # 1 出现的次数
print(tup.index('2'))  # 1 出现的位置
print('%s' % tup)  # 元组里有多少内容，就有多少格式%（对应）
sr = '%d %d %d' % tup  # 赋值给一个字符串

字典

dic = {1: 'a', 2: 'b', 3: 'c'}  # key 是唯一的
print(dic.values())  # 所有values组成列表
print(dic.keys())  # 所有key组成列表
print(dic.get(1))  # 以key找出value
print(dic[1])  # 输出 key(1) 对应的value
print(len(dic))  # 输出key 的个数
dic.update({8: 'd'})  # 更新键值对， key相同替换value， 负责加到字典后面
print(dic)
for i in dic.values():
    print(i)
dic.pop(3)  # 删去 key（3） 及其value
for key, value in dic.items():  # 迭代key,value
    print(key, '-', value)

字符串

1，去掉空格和特殊符号
name.strip()  去掉空格和换行符
name.strip('xx')  去掉某个字符串
name.lstrip()  去掉左边的空格和换行符
name.rstrip()  去掉右边的空格和换行符

2，字符串的搜索和替换
name.count('x')  查找某个字符在字符串里面出现的次数
name.capitalize()  首字母大写
name.center(n,'-')   把字符串放在n个字符中间，两边用- 补齐
name.find('x')   找到这个字符返回下标，多个时返回第一个；不存在的字符返回-1
name.index('x') 找到这个字符返回下标，多个时返回第一个；不存在的字符报错
name.replace(oldstr, newstr)  字符串替换
name.format（） 字符串格式化
name.format_map(d)  字符串格式化，传进去的是一个字典

3，字符串的测试和替换函数
S.startswith(str) #是否以str开头 
S.endswith(str) #以str结尾 
S.isalnum() 
#是否全是字母和数字，并至少有一个字符 
S.isalpha() #是否全是字母，并至少有一个字符 

s.isdigit()  # 可以判断特殊数字 列如：(1)
s.isdecimal()  # 只能判断常规数字
s.isnumeric()  # 可以判断特殊数字 列如：(1);判断中文数字 列如：一千零一

S.isspace() #是否全是空白字符，并至少有一个字符 
S.islower() #S中的字母是否全是小写 
S.isupper() #S中的字母是否便是大写 
S.istitle() #S是否是首字母大写的

4，字符串的分割
name.split()  # 默认是按照空格分割
name.split(',')   # 按照逗号分割
name.partition('str')  # 差分为三个字符串 str前 str str后
5，连接字符串
‘，’.join(slit)   用逗号连接slit 变成一个字符串，slit 可以是字符，列表，字典（可迭代的对象）
int 类型不能被连接

6，截取字符串（切片）
str = '0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取

多值参数

1.参数名前加一个 * ：可以接收元组

2.参数名前加两个 * ：可以接收字典

注： 调用时，不需要使用元组，字典而是直接传值 (使用拆包最好，元组变量前+ *，字典变量前 + **) ：

调用： ifnum(1,2,3, name=‘2’)

结果：args = (1,2,3) kwargs = {“name”: “2”}

面向对象

__doc__ : 函数说明
__new__ : 创建对象时，会被自动调用
__init__ : 对象被初始化时，会被自动调用
__del__ : 对象从内存中销毁前，会被自动调用
__str__ : 返回对象的描述信息，print函数输出使用

定义简单类

class Cat:
    def eat(self):
        """吃"""
        print("小猫爱吃鱼")

    def drink(self):
        """喝"""
        print("小猫爱喝水")


if __name__ == '__main__':
    # 第一个对象
    print("tom:")
    tom = Cat()
    # 可以使用  .属性名 利用赋值语句就可以了
    tom.name = "Tom"  # 增加属性,不推荐使用
    print(tom.name)
    tom.eat()
    tom.drink()
    
    # 第二个对象
    print("lazy:")
    lazy = Cat()
    lazy.eat()
    lazy.drink()

self方法

class Cat:
    def eat(self):
        """吃"""
        # 哪一个对象调用方法，self 就是哪一个对象的引用
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        """喝"""
        print("%s 爱喝水" % self.name)


if __name__ == '__main__':
    # 第一个对象
    print("tom:")
    tom = Cat()
    # 可以使用  .属性名 利用赋值语句就可以了
    tom.name = "Tom"
    tom.eat()
    tom.drink()

    # 第二个对象
    print("lazy:")
    lazy = Cat()
    lazy.name = "大懒猫"
    lazy.eat()
    lazy.drink()

初始化方法

class Cat:
    def __init__(self, new_name):  # 初始化的同时设置初始值
        """初始化方法(定义属性)"""
        # self.name = "小猫"
        self.name = new_name

    def eat(self):
        """吃"""
        # 哪一个对象调用方法，self 就是哪一个对象的引用
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        """喝"""
        print("%s 爱喝水" % self.name)


if __name__ == '__main__':
    # 第一个对象
    tom = Cat("Tom")
    tom.eat()
    tom.drink()

    # 第二个对象
    lazy = Cat("大懒猫")
    lazy.eat()
    lazy.drink()

–del–方法

class Cat:
    def __init__(self, new_name):  # 初始化的同时设置初始值
        """初始化方法(定义属性)"""
        # self.name = "小猫"
        self.name = new_name

    def eat(self):
        """吃"""
        # 哪一个对象调用方法，self 就是哪一个对象的引用
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        """喝"""
        print("%s 爱喝水" % self.name)

    def __del__(self):  # 调用的最后方法，生命周期结束（做最后的事）
        print("%s  我去了" % self.name)


if __name__ == '__main__':
    # 第一个对象
    tom = Cat("Tom")
    tom.eat()
    tom.drink()
    del tom  # 调用__del__方法，最后的方法
    print('-' * 50)

–str–方法

class Cat:
    def __init__(self, new_name):  # 初始化的同时设置初始值
        """初始化方法(定义属性)"""
        # self.name = "小猫"
        self.name = new_name

    def eat(self):
        """吃"""
        # 哪一个对象调用方法，self 就是哪一个对象的引用
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        """喝"""
        print("%s 爱喝水" % self.name)

    def __del__(self):  # 调用的最后方法，生命周期结束（做最后的事）
        print("%s  我去了" % self.name)

    def __str__(self):
        # 如果在开发时，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用这个内置方法
        return "我是你爸爸[%s]" % self.name  # 必须返回一个字符串


if __name__ == '__main__':
    # 第一个对象
    tom = Cat("Tom")
    print(tom)
    del tom  # 调用__del__方法，最后的方法
    print('-' * 50)

封装

  1. 封装是面向对象编程的一大特点
  2. 面向对象编程的第一步–将 属性 和 方法 封装到一个抽象的 类 中
  3. 外界 使用 类 创建对象，然后让 对象调用方法
  4. 对象方法的细节 都被封装在 类 的内部
class Xiao:
    def __init__(self, name, weight):  # 初始化的同时设置初始值
        """初始化方法(定义属性)"""
        # self.name = "小猫"
        self.name = name
        self.weight = weight

    def __str__(self):
        # 如果在开发时，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用这个内置方法
        return "我是的名字是：%s  体重是：%.2f" % (self.name, self.weight)  # 必须返回一个字符串

    def run(self):
        print("%s 爱跑步" % self.name)
        self.weight -= 0.5

    def eat(self):
        print("%s  爱吃" % self.name)
        self.weight += 0.5


if __name__ == '__main__':
    xiao = Xiao("小明", 75.0)
    xiao.run()
    xiao.eat()
    print(xiao)

家具实例

class House_item:  # 家具类
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):  # 返回方法
        return "%s 占地 %.2f" % (self.name, self.area)


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具名称列表
        self.item_list = []

    def __str__(self):
        return "户型: %s\n总面积: %.2f[剩余: %.2f]\n家具:%s" \
               % (self.house_type, self.area, self.free_area, self.item_list)

    def add_item(self, item):  # item 是House_item对象
        print("要添加 %s" % item)
        # 判断家具的面积
        if item.area > self.free_area:
            print("%s 的面积太大了，无法添加" % item.name)
            return
        # 将家具名称添加到列表中
        self.item_list.append(item.name)
        # 计算剩余面积
        self.free_area -= item.area


if __name__ == '__main__':
    # 创建家居
    bed = House_item("席梦思", 4)
    chest = House_item("衣柜", 2)
    table = House_item("餐桌", 1)

    # 创建房子对象
    home = House("两室一厅", 60)
    home.add_item(bed)
    home.add_item(chest)
    home.add_item(table)
    print(home)

开枪实例

class Gun:
    def __init__(self, model):
        # 枪的型号
        self.model = model
        # 子弹数量
        self.bullet_count = 0

    def add_bullet(self, count):
        """增加子弹"""
        self.bullet_count += count

    def shoot(self):
        """发射"""
        # 1.判断子弹数量
        if self.bullet_count <= 0:
            print("%s没有子弹了" % self.model)
            return
        # 2.发射子弹
        self.bullet_count -= 1
        # 3.提示发射信息
        print("%s 哒哒哒... %d" % (self.model, self.bullet_count))


class Solider:
    def __init__(self, name):
        self.name = name
        # 枪
        self.qun = None  # 如果不知道设置什么初始值，可以设置为None

    def __str__(self):
        return "士兵 %s 使用 %s 开火" % (self.name, self.qun)

    def fire(self):
        # 1.判断士兵是否有枪
        if self.qun is None:
            print("%s 还没有枪..." % self.name)
            return
        # 2.高喊口号
        print("冲啊...%s" % self.name)
        # 3.让枪装填子弹
        self.qun.add_bullet(50)
        # 4.让枪发射子弹
        self.qun.shoot()


if __name__ == '__main__':
    # 创建枪对象
    gun = Gun("AK47")
    # 创建对象
    solider = Solider("许三多")
    solider.qun = gun  # 先前的枪对象给士兵
    solider.fire()

私有属性 私有方法

定义： 在属性名或方法名前 增加两个下划线

外界无法访问

class Woman:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def __secret(self):
        # 在对象的方法内部是可以访问私有属性的
        print("%s 的年龄是 %d" % (self.name, self.__age))


if __name__ == '__main__':
    xiaofang = Woman("小方")

    # 私有属性在外界不能被直接访问
#     print(xiaofang.__age)
    # 私有方法同样不能再外部进行访问
#     xiaofang.__secret()
   # 可以通过此方法访问，python中没有真正的私有
    xiaofang._Woman__secret()

继承

特性：实现代码的重用相同的代码，不需要重复编写

概念：子类 拥有 父类 的所有属性和方法

单继承

继承的语法

class 类名（父类）:

	pass

特性：传递性：父 <- - 子 <-- 子。。。。。。。。。。。

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


class Dog(Animal):
    def bark(self):
        print("汪汪汪")


class Xiaotianqun(Dog):
    def fly(self):
        print("我会飞")


if __name__ == '__main__':
    # 创建一个对象
    wangcai = Xiaotianqun()
    wangcai.eat()
    wangcai.sleep()
    wangcai.run()
    wangcai.drink()
    wangcai.bark()
    wangcai.fly()

方法的重写

  • 在子类中定义一个和父类同名的方法

  • 使用 super().父类方法 调用原本在父类中封装的方法

class Animal:

    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print("睡")


class Dog(Animal):
    def bark(self):
        print("汪汪汪")


class Xiaotianqun(Dog):
    def fly(self):
        print("我会飞")

    def bark(self):
        """方法的重写+扩展"""
        
        # 针对子类特有的需求，编写代码
        print("噢噢噢叫")
        
        # 使用   super().父类方法  调用原本在父类中封装的方法
        super(Xiaotianqun, self).bark()
        
        # 增加其他子类的代码
        print("啦啦啦啦叫")


if __name__ == '__main__':
    # 创建一个对象
    wangcai = Xiaotianqun()
    wangcai.bark()

私有属性 私有方法

class A:

    def __init__(self):
        self.num1 = 100
        self.num2 = 200

    def __test(self):
        print("私有方法 %d  %d" % (self.num1, self.num2))

    def test(self):
        print("父类的公有方法 %d" % self.num2)
        self.__test()


class B(A):

    def demo(self):

        # 1.在子类的对象方法中，不能访问父类的私有属性
        # print("访问父类的私有属性 %d" % self.__num2)
        # 2.在子类的对象方法中，不能调用父类的私有方法
        # self.__test()
        # 3.访问父类的公有属性
        print("子类方法  %d" % self.num1)
        # 4.调用父类的公有方法
        self.test()
        pass


if __name__ == '__main__':
    # 创建一个子类对象
    b = B()
    print(b)

    b.demo()
    # print(b.num1)
    # b.test()
    # 在外界不能直接访问对象的私有属性/调用方法
    # b.__num2

多继承

多继承尽量少用，容易混乱

class A:

    def test(self):
        print("A-test")

    def demo(self):
        print("A-demo")


class B:

    def demo(self):
        print("B-demo")

    def test(self):
        print("B-test")


class C(A, B):
    """多继承可以让子类拥有多个父类方法属性"""
    pass


if __name__ == '__main__':
    c = C()
    c.test()
    c.demo()
    # 确定c类对象调用的对象
    print(C.__mro__)

多态

  • 不同子类对象调用相同父类方法，产生不同的结果

  • 可以增加代码的灵活性

  • 已继承和重写父类方法为前提

  • 是调用方法的技巧，不会影响到类的内部设计

class Dog:

    def __init__(self, name):
        self.name = name

    def game(self):
        print("%s 吃屎" % self.name)


class Xiao(Dog):

    def game(self):
        print("%s 不吃屎" % self.name)


class Person(Dog):

    def __init__(self, name):
        self.name = name

    def game_with_god(self, dog):

        print("%s 和 %s 快乐吃屎" % (self.name, dog.name))

        # 让狗玩耍
        dog.game()


if __name__ == '__main__':
    # 1.创建一个狗对象
    # wc = Dog("旺财")
    wc = Xiao("飞天旺财")

    # 2.创建一个黄欣宇对象
    hxy = Person("黄欣宇")

    # 3.让黄欣宇调用和狗玩耍的方法
    hxy.game_with_god(wc)

类属性

class Tool:
    # 使用赋值语句定义类属性
    count = 0

    def __init__(self, name):
        self.name = name

        # 让类属性+1
        Tool.count += 1


if __name__ == '__main__':
    # 创建工具对象
    t1 = Tool("斧头")
    t2 = Tool("榔头")
    # 输出工具对象个数   类名.类属性
    print(Tool.count)
    
    # 对象.类属性   （不推荐）
    print(t1.count)

类方法和静态方法

class Tool:
    # 使用赋值语句定义类属性
    count = 0

    @classmethod
    def class_tool_count(cls):
        """类方法"""
        print("工具对象数量 %d" % cls.count)

    @staticmethod
    def static_tool_count():
        """既不需要访问实例属性或者调用实例方法
            也不需要访问类属性或者调用类方法
        """
        print("静态方法")

    def __init__(self, name):
        self.name = name

        # 让类属性+1
        Tool.count += 1


if __name__ == '__main__':
    # 创建工具对象
    t1 = Tool("斧头")
    t2 = Tool("榔头")
    # # 输出工具对象个数   类名.类属性
    # print(Tool.count)
    #
    # # 对象.类属性   （不推荐）
    # print(t1.count)

    # 调用类方法
    Tool.class_tool_count()
    # 调用静态方法
    Tool.static_tool_count()

实战

  • 实例方法：方法内部需要访问实例属性
    • 实例方法内部可以使用类名没访问类属性
  • 类方法：方法内部只需要访问类属性
  • 静态方法：方法内部，不需要访问实例属性 和 类属性
class Game(object):

    # 类属性
    top_score = 0  # 历史最高分

    def __init__(self, palyer_name):  # 实例属性
        self.player_name = palyer_name

    @staticmethod  # 静态方法
    def show_help():

        print("帮助信息:植物大战僵尸")

    @classmethod  # 类方法
    def show_top_score(cls):
        print("历史记录 %d" % cls.top_score)

    def start_game(self):  # 实例方法
        print("%s 开始游戏啦...." % self.player_name)


# 1.查看游戏帮助信息
Game.show_help()

# 2.查看历史最高分
Game.show_top_score()

# 3.创建游戏对象
wo = Game("黄欣宇")
wo.start_game()

单例

__ new __方法

  • __ new __是一个有object 基类提供的 内置静态方法 ，只要作用有两个：
    • 在内存中为对象 分配空间
    • 返回对象的引用
  • python 解释器获得对象的引用后，将引用作为 第一个参数，传递给__ init __方法
  • 重写__ new __方法的代码非常固定
  • 重写__ new __ 方法一定要 return super(). __ new __(cls)
  • 否则python解释器 得不到分配了空间的 对象引用，就不会调用对象的初始化方法
  • 注意：__ new __是一个静态方法，在调用时需要主动传递cls参数
class MusicPlayer(object):
    def __new__(cls, *args, **kwargs):  # 重写object new 方法

        # 1.创建对象时，new  方法会被自动调用
        print("创建对象，分配空间")

        # 2.为对象分配空间
        instance = super().__new__(cls)

        # 3.new方法，必须返回对象的引用, 才可以调用初始化方法
        return instance

    def __init__(self):
        print("播放器初始化")


# 创建播放器对象
player = MusicPlayer()
print(player)

单例类

初始化方法每次都调用
class MusicPlayer(object):  # 只创建 唯一 的实例对象

    # 类属性
    instance = None  # 记录单例对象的引用

    def __new__(cls, *args, **kwargs):  # 重写object new 方法

        # 1.判断类属性是否是空对象
        if cls.instance is None:
            # 2.如果对象没有被创建，调用父类方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)

        # 3.返回类属性保存的对象引用
        return cls.instance

    def __init__(self):
        print("播放器初始化")


# 创建播放器对象
player1 = MusicPlayer()
print(player1)

player2 = MusicPlayer()
print(player2)

/**
播放器初始化
<__main__.MusicPlayer object at 0x00000196AA7CFEE0>
播放器初始化
<__main__.MusicPlayer object at 0x00000196AA7CFEE0>
初始化方法只调用一次
class MusicPlayer(object):  # 只创建 唯一 的实例对象

    # 类属性
    instance = None  # 记录单例对象的引用
    init_flag = False  # 记录是否执行过初始化动作

    def __new__(cls, *args, **kwargs):  # 重写object new 方法

        # 1.判断类属性是否是空对象
        if cls.instance is None:
            # 2.如果对象没有被创建，调用父类方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)

        # 3.返回类属性保存的对象引用
        return cls.instance

    def __init__(self):
        # 1.判断是否执行过初始化动作
        if MusicPlayer.init_flag:
            return
        # 2.如果没有执行过，在执行
        print("播放器初始化")
        # 修改雷类属性标志
        MusicPlayer.init_flag = True


# 创建播放器对象
player1 = MusicPlayer()
print(player1)

player2 = MusicPlayer()
print(player2)

异常

简单

try:
    # 不能确定正确执行的代码
    n = int(input())
except:
    # 错误的处理代码
    print("输入错误")

错误类型捕获+完整捕获

try:
    # 不能确定正确执行的代码
    n = int(input("请输入整数:"))
    result = 10 / n
    print(result)
# except TypeError:  # 解析器抛出异常代码最后一行的第一个单词
#     print("TypeError")
# except ZeroDivisionError:
#     print("n 不能为 0")
except ValueError:
    print("输入的不是整数")
except Exception as result:  # 抛出未知错误， 并且可以说明错误原因
    print("未知类型错误  %s" % result)
else:
    # 没有异常时执行的语法
    print("没有错误时，才会用到我")
finally:
    # 无论有没有错误都会执行
    print("我一定会执行")
print("我也一定会执行")

异常的传递

def demo1():
    return int(input("输入整数"))


def demo2():
    return demo1()


# 利用异常的传递性，在主程序中捕获异常
try:
    print(demo2())
except Exception as result:
    print("未知错误 %s" % result)

主动抛出异常

def input_password():

    # 1.提示用戶輸入密碼
    pwd = input("请输入密码：")
    # 2.判斷密码长度
    if len(pwd) >= 8:
        return pwd
    # 3，如果  < 8 就抛出异常
    print("主动抛出异常")
    
    # 1>创建异常对象  - 可以使用错误信息字符串作为参数
    ex = Exception("密码长度不够")
    # 2>主动抛出异常
    raise ex


# 提示用户输入密码
try:
    print(input_password())
except Exception as result:
    print(result)

文件

  • w :以只写的方式打开文件
  • r :以只读的方式打开文件
  • a :已追加的方式打开文件，如果文件存在从末位开始操作，没有就会创建新文件写入
  • w+ :以读写方式打开文件。文件的指针放在文件的开头
  • r+ :以读写方式打开文件。如果文件存在会被覆盖，如果不存在，创建新文件
  • a+ :以读写方式打开文件。如果文件存在，文件指针放在末尾否则创建新文件写入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-01ZKCgyJ-1650532250756)(file:///D:\QQ\MobileFile\2750317105\Image\C2C\B430FCC937DE53850A98A198B5EA88A3.png)]

eval()函数

  • 将字符串内容当成有效表达式

  • n = input("请输入算术题:")
print(eval(n))

是整数")
except Exception as result: # 抛出未知错误， 并且可以说明错误原因
print(“未知类型错误 %s” % result)
else:
# 没有异常时执行的语法
print(“没有错误时，才会用到我”)
finally:
# 无论有没有错误都会执行
print(“我一定会执行”)
print(“我也一定会执行”)


### 异常的传递

```python
def demo1():
    return int(input("输入整数"))


def demo2():
    return demo1()


# 利用异常的传递性，在主程序中捕获异常
try:
    print(demo2())
except Exception as result:
    print("未知错误 %s" % result)

主动抛出异常

def input_password():

    # 1.提示用戶輸入密碼
    pwd = input("请输入密码：")
    # 2.判斷密码长度
    if len(pwd) >= 8:
        return pwd
    # 3，如果  < 8 就抛出异常
    print("主动抛出异常")
    
    # 1>创建异常对象  - 可以使用错误信息字符串作为参数
    ex = Exception("密码长度不够")
    # 2>主动抛出异常
    raise ex


# 提示用户输入密码
try:
    print(input_password())
except Exception as result:
    print(result)

文件

  • w :以只写的方式打开文件
  • r :以只读的方式打开文件
  • a :已追加的方式打开文件，如果文件存在从末位开始操作，没有就会创建新文件写入
  • w+ :以读写方式打开文件。文件的指针放在文件的开头
  • r+ :以读写方式打开文件。如果文件存在会被覆盖，如果不存在，创建新文件
  • a+ :以读写方式打开文件。如果文件存在，文件指针放在末尾否则创建新文件写入

[外链图片转存中…(img-01ZKCgyJ-1650532250756)]

eval()函数

  • 将字符串内容当成有效表达式

  • n = input("请输入算术题:")
print(eval(n))
L-xykeen
关注
python语法基础（一）
qq_28808527的博客
06-07 873
for循环做的事情其实就是遍历一个list列表中的每一项，每次循环都把当前项赋值给一个变量（这里是i），直到列表结束继续学习python基础，发现一个cossin的公众号，里面的内容比较简短 早上学到了26课，贴上一些认为比较有价值的代码一个很弱智的猜数字小游戏：from random import randint num = randint(1, 100) print('guess what I...
python第七次课----常用模块
huo130125的博客
03-23 1125
模块的概念 在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似 ，在python中一个脚本(.py)文件就是一个模块，创建模块实际上就是创建一个.py文件，可以被其 他模块导入并使用比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块； 说的通俗点：模块就好比是工具包，要想使用这个工具包中的工具(就好比函数)，就需要导入这个 模块模块的优点：便于团队开发，方便维护，代码复用。 下面就来了解一下Python中的模块。
python中的模块简单了解
Duan
09-20 342
模块使用 模块就像工具包一样，里面有很多工具(函数、类等)，使用时导入即可 分类： 标准库：random、sys、os、time 第三方：就是别人写好的一些模块，你自己拿来使用(使用pip即可进行安装) 自定义：自己写的 导入： import random # 导入 import random as rdm # 导入后起别名 from random import randint #...
python常用函数使用
yuanYW7556的博客
05-28 789
#计算求最值和求和等 from random import randint a=[randint(1,100) for i in range(12)]#生成12个100之内的随机整数，采用的是列表推导式 print(a) print(max(a),min(a),sum(a))#求出a的最大值最小值和总值 print(sum(a)/len(a))#求平均值 #使用列表推导式 from random ...
10-11
weixin_48959912的博客
10-12 376
函数 函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。 如果没有return语句，函数执行完毕后也会返回结果，只是结果为undefined 定义方法一： 在JavaScript中，定义函数的方式如下： function abs(x) { if (x >= 0) { return x; } else { return -x; } } 上述abs()函数的定义如下： function指出这是一个函数定义； abs是函
python基础语法合集68页.pdf
05-08
在实际编程中，了解这些基础知识是学习Python的第一步，它们构成了Python语法的核心，为后续的进阶学习和实际项目开发打下坚实基础。无论是初学者还是有经验的程序员，熟悉并掌握这些基本概念和用法都是至关重要的。
python基础教程PPT课件.pdf
最新发布
06-12
python基础教程PPT课件.pdf该文档详细且完整，值得借鉴下载使用，欢迎下载使用，有问题可以第一时间联系作者~
python基础练习题100道.zip
06-05
python基础练习题100道
老王Python基础+进阶+项目篇（高清无密）
06-07
一、Python基础概述 二、Python基础教程 老王Python教程 基础篇 基础篇1-福利课python先入为主上 基础篇2-福利课-python先入为主下篇 基础篇3-虚拟机安装xubuntu开发环境 基础篇4-linux基本命令以及开发环境 基础篇...
Python基础实验操作（一）
weixin_51594673的博客
11-27 9810
实验一 Python 基本操作 主要实验内容 print 、input 语句、pip 安装第三方库以及标准库的使用 1. print 语句 按照以下三张图片编程实现（实现以下任一个） print(''' @@@@@@@@@@@ @@@@ @@@@ @@@ @ @@@ @@ @@@ @@ @@@ @ @@@ @@@@ @@@@ @@@@@@@@@@@ ''' ) print(''' ++++++++++++ + + +++++++++++++ ''') print(''' 学Python,来
python中的random模块来随机生成整数、随机在列表中选择函数
hmysn的博客
07-12 1825
模块random可以帮助我们模拟很多现实中的随机情况1、随机生成整数： 2、在模块random中，另一个有用的函数是choice（），它将一个列表或者元组作为参数，并返回其中的一个元素：
python基础 - 生成随机数组
热门推荐
Rnan_prince的博客
06-14 1万+
一、random模块 python的random模块中有一些生成随机数字的方法，例如random.randint， random.random, random.uniform, random.randrange，这些函数大同小异，均是在返回指定范围内的一个整数或浮点数，下边简单解释一下这几个函数。 from random import random from random import randint from random import uniform from random import rand
pyhon-面向对象
qq_31521965的博客
10-02 346
今天在敲代码的时候碰到一个问题。关于import和from....import...的区别。 eg import random 表示引入的是random模块或者说random.py文件,那么自然random里的类都可以使用。使用方式 random.randint(0, last_pos) 而from random import randint 表示将random中randint函...
python中random模块中randint(),choice()函数的使用。
qq_55977139的博客
01-22 2775
>>>from random import randint >>>randint(1,6) 3 他将两个整数作为参数，并随机返回一个位于这两个整数之间的整数。 ----------- >>>from random import choice >>>players［'charles', 'martina', 'michael', 'florence'］ >>>first_up = choice(player
掌握如何导入模块，常用函数time，radom #导入内置模块 import time import random #根据需求自定义导入 #from random import randint
beyongboy的博客
03-16 821
if __name__ == '__main__': # time模块中返回时间元祖的方法 listTime=time .localtime() print(listTime) # 获取时间戳 liseTime1=time.time() print(listTime1) #日期格式化 strFromat= "%Y-%m-%d %H:%M:%S" st...
python包_3_随机函数— random包
theagao&leozhang
04-16 5575
random是内建（built-in）函数，作用是产生随机数，使用较多.首先是导入模块：import random接着就可以调用random模块下的函数了。使用下面命令语句可以查看random包所包含的内容：dir(random)['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRando...
python导入随机数模块_python如何导入random模块
weixin_31138555的博客
01-13 4512
random不是python解释器内置的模块，它不是Python解析器的内置模块。 导入random模块的方法是：importrandom例如:我想生成一个10以内的随机的整数，不需要random模块的别的方法的时候，也可以使用以下命令fromrandomimportrandintrandom.randint(0,10)查看random模块的内置方法：dir(random)其中常用的方法有...
pythonrandint用法_Python randint()用法及代码示例
weixin_39786141的博客
11-21 4086
randint()是Python3中随机模块的内置函数。随机模块提供对各种有用功能的访问，其中一个功能可以生成随机数，即randint()。句法：randint(start, end)参数：(start, end): Both of them must be integer type values.返回值：A random integer within the given range as par...
掌握Python基础：从代码大全起步
【标题】所指的“python基础代码大全”可能是一个集合了Python基础学习者需要掌握的关键代码的资源。它可能包括了基础的语法元素、数据结构的操作、基本的控制流结构（如if语句、for和while循环）以及函数定义等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值