美文网首页
Python 第二周

Python 第二周

作者: 云顶天宫写代码 | 来源:发表于2023-08-11 13:50 被阅读0次

集合相关

# 集合的创建
set1 = set()
dict1 = dict()
tuple1 = tuple()
str1 = str()
int1 = int('10')
list1 = list()

# 数字/字符串/元组
set2 = {12, 'str', (1,)}

list2 = ['张三', '张三', '李四', '王五']  # 有重复元素的 列表
set2 = set(list2)  # 去重
print(set2)
list2 = list(set2)
print(list2)  # 去重后转换回来

# 集合的新增  add(元素)
set2.add('赵六')
print(set2)

# pop() 随机删除一个元素  remove(指定元素)  删除指定元素,如果不存在报错   discard(指定元素) 删除指定元素,如果不存在None
# clear() 清空集合

# 集合关系

# & 交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}

print(s1 & s2)  # {2, 3}

# | 并集
print(s1 | s2)

# - 差集
print(s1 - s2, s2 - s1)  # 结果不一样

# ^ 对称差集   找出两个集合中除了共有元素之外的所有元素
print(s1 ^ s2)

# 子集
s2 = {1, 2, 3, 4}
s1 < s2  # 子集
s2 > s1  # 超集

一、函数相关知识点

函数定义
定义函数,也就是创建一个函数,可以理解为创建一个具有某些用途的工具。定义函数需要用 def 关键字实现。

1. 函数定义

1.1语法格式

def 函数名(参数列表):
   //实现特定功能的多行代码
    [return [返回值]]

1.2 参数的含义

    函数名:其实就是一个符合 Python 语法的标识符,但不建议读者使用 a、b、c 这类简单的标识符作为函数名,函数名最好能够体现出该函数的功能(如上面的 my_len,即表示我们自定义的 len() 函数)。形参列表:设置该函数可以接收多少个参数,多个参数之间用逗号( , )分隔。[return [返回值] ]:整体作为函数的可选参参数,用于设置该函数的返回值。也就是说,一个函数,可以用返回值,也可以没有返回值,是否需要根据实际情况而定。

1.3 注意事项

    在创建函数时,即使函数不需要参数,也必须保留一对空的“()”,否则 Python 解释器将提示“invaild syntax”错误。另外,如果想定义

2. 函数参数

2.1 必选参数

# 必选参数:顾名思义,就是函数必须有的入参; 
def ice_box2(a, b):  # a 容器  b 动物
    print("把%s门打开" % a)
    print("把%s装进去" % b)
    print("把%s门关上" % a)

# 位置参数
ice_box2('汽车', '长颈鹿')  # 根据位置 传入 数据

# 关键参数 使用形参赋值的方式传递参数。 不考虑顺序
ice_box2(b="长颈鹿", a="汽车")

2.2 默认参数

# 默认参数:在函数定义时给定一个初始值,在函数调用时可以不传这个参数,采用默认参数的值;下例中的y就是默认参数;
def ice_box3(brand, anim, animList=[]):  # animList 默认参数
    print("把%s冰箱门打开" % brand)
    print("把%s装进去" % anim)
    print("把%s冰箱门关上" % brand)
    if len(animList) == 0:
        print("没有可装的动物了")
    else:
        print("继续装入")
# 注意:设置默认参数时,必选参数在前,默认参数在后!

2.3 可选(不定长)参数

# 可选参数:顾名思义,函数参数的个数是可变的,例如下面的args就是可变参数。
def eat_and_drink(a, b, *args):  # a 早餐  b午餐   args零食
    print(a, b)
    print("零食", args)  # args = ('方便面', '辣条', '瓜子')

2.4 关键字参数

# 关键字参数:可选参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。

def eat_and_drink2(a, b, *args, action="吃", **kwargs):
    print("eat_and_drink2 我要 %s " % action, "a=%s" % a, "b=%s" % b)
    print("eat_and_drink2 我要 %s " % action, "args=", args)
    print("eat_and_drink2 我要 %s " % action, "kwargs=", kwargs)
    print("eat_and_drink2 %s 饱了" % action)

eat_and_drink2('豆浆', '太钢汽水', '冰红茶', action="喝", sx="和子饭", bj="豆汁")
# 无返回值的函数  类型是None
print(eat_and_drink2('豆浆', '太钢汽水', '冰红茶', action="喝", sx="和子饭", bj="豆汁"))

2.5 函数嵌套

def func1():
    print("fun1执行")


def func2():
    func1()
    print("fun2执行")

2.6 总结

函数参数的用法是非常灵活的,既可以简单调用,也可以传入复杂的参数。
默认参数一定要用不可变对象,如果是可变对象,程序运行时会有逻辑错误!
要注意定义可变参数和关键字参数的语法:
*args是可变参数,args接收的是一个tuple;
**kw是关键字参数,kw接收的是一个dict。

3. 函数作用域

3.1作用域指的是变量的有效范围

通常,函数内部的变量无法被函数外部访问,但内部可以访问;类内部的变量无法被外部访问,但类的内部可以。通俗来讲,就是内部代码可以访问外部变量,而外部代码通常无法访问内部变量。

3.2全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域,被叫做局部变量
定义在函数外的拥有全局作用域的变量,被称为全局变量。(类、模块等同理)# 所谓的局部变量是相对的。局部变量也有可能是更小范围内的变量的外部变量。

# 实例
a = 1               # 全局变量
def func():
    b = 2           # 局部变量
    print(a)        # 可访问全局变量a,无法访问它内部的c
    def inner():
        c = 3       # 更局部的变量
    print(a)    # 可以访问全局变量a
    print(b)    # b对于inner函数来说,就是外部变量
    print(c)

global关键字
global:指定当前变量使用外部的全局变量 尽量不要这样操作

4 函数进阶

4.2闭包

# 闭包的由来,想让一个变量提供给其他函数去使用,不用修改
def func():
    name = "我初始化一次,不可被修改,常驻内存"
    def inner():
        print(name) # name是func中的一个局部变量,inner方法还在引用,所以内存会保留下来
    return inner

test1 = func()  # 1 func()   2 将返回的inner 赋值给 test1
# test2 = func
test1()
test1()
test1()
test1()

4.2装饰器

# 装饰器
def modify_phone(function_name):
    print('-----装饰手机1------')
    def inner():
        print('加装手机壳')
        return function_name()
    return inner

def modify_phone2(function_name):
    print('-----装饰手机2------')
    def inner():
        print('贴钢化膜')
        return function_name()
    return inner

def modify_phone3(function_name):
    print('-----装饰手机3------')
    def inner():
        print('蓝牙耳机')
        return function_name()
    return inner

@modify_phone    #  由上而下  多装饰器 外层函数由下而上  内层函数由上而下
@modify_phone2
@modify_phone3
def phone():
    print('装饰手机')

result = phone()  # 先执行装饰器的函数 最后执行phone()


# 带参数的装饰器
def func4(arg1,arg2):
    def modify_phone(function_name):
        print(arg1)
        def inner():
            print(arg2)
            return function_name()
        return inneruytygbh
    return modify_phone

@func4('第二次装饰','钢化膜')
@func4('第一次装饰','手机壳')
def phone():
    print('装饰手机')

4.3常用的内建函数

eval(): 将字符串作为 代码表达式执行, 返回结果
exec(): 执行动态语句
map():  将可迭代的对象 转换位新的可迭代对象
filter(): 对序列进行过滤,返回值为True的元素
zip(): 将多个可迭代的对象打包成一个元组
len(): 返回序列的长度
sorted(): 对可迭代对象进行排序
min(): 返回可迭代对象中的最小的值
max(): 返回可迭代对象中的最大值、
sum(): 求和, 元素必须是数字类型
reversed(): 返回逆序的可迭代对象
range(): 快速生成一个数字序列

4.4 迭代器

iter() 调用迭代器 next() 取数据
iter() 和 next() 都存在迭代器。 iter() 只有一个存在可迭代对象

5. 面向对象

 OOP  面向对象编程

# 面向过程 1,把冰箱门打开  2. 把大象装进去 3. 关上冰箱门
# 面向对象  大象装进冰箱

class 类名:  类名使用大驼峰命名  Person   AsianPerson
    def 函数名(self,[形式参数]):
        self.属性 = 值
        函数体

    def __init__(self,[形式参数]): # 构造函数
        self.属性 = 值

# 面向对象 三大特征 封装 继承 多态
封装
将属性和方法书写到类的里面的操作即为封装
封装可以为属性和方法添加私有权限
继承
子类默认继承父类的所有属性和方法
子类可以重写父类属性和方法
多态
传入不同的对象,产生不同的结果
使用规则
# 对象语法
  对象名 = 类名()
  self: 指的是调用该函数的对象本身
# 类外面获取对象属性
  对象名.属性名
# 类里面获取对象属性
  self.属性名
内置函数(魔法)
1. __init__()方法的作用:初始化对象时自动调用。
2. 带参数的__init__()
思考:一个类可以创建多个对象,如何对不同的对象设置不同的初始化属性呢
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
3.__str__()
当使用print输出对象的时候,默认打印对象的内存地址。如果类定义了__str__方法,那么就会打印从在这个方法中 return 的数据。
class IceBox():
    def __init__(self, width, height):
        self.width = width
        self.height = height

   def __str__(self):
        return '这是海尔冰箱的说明书'
haier1 = IceBox(10, 20)
# 这是海尔洗衣机的说明书
print(haier1)

5.1封装

封装实例代码
class Box:
    def __init__(self,name):  # 构造方法   name是形参
        self.name = name
        self.animList = []  # 装动物的空间

    def open_door(self):
        print('%s门打开' % self.name)

    def push(self,anim):
        self.animList.append(anim)

    def close_door(self):
        print('%s门关闭' % self.name)

    def __str__(self):  # 打印对象描述信息
        return self.name+'装了'+str(len(self.animList))+'只动物'

box = Box('冰箱')   # Box 的 __init__方法执行
box.open_door()
box.push('大象')
box.close_door()
print(box)       # __str__方法执行

box2 = Box('笼子')
box2.open_door()
box2.push('雪豹')
box2.push('老虎')
box2.close_door()
print(box2)

5.2 继承

Python面向对象的继承指的是多个类之间的所属关系,即子类默认继承父类的所有属性和方法,具体如下:

# 父类A
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

# 子类B
class B(A):
    pass

result = B()
result.info_print()  # 1

在Python中,所有类默认继承object类,object类是顶级类或基类;其他子类叫做派生类。

5.3 单继承实例

class Animal:
    def __init__(self):
        print('我是一个动物,会动。 初始化完成')

    def action(self):
        print("这是动物的行为")


class Dog(Animal):  # 单继承
    def __init__(self):
        super().__init__()
        super().action()
        print('我是一只狗。 初始化完成')

super()调用父类方法

5.4 多继承

class Train:
    def __init__(self):
        print('训练类 初始化完成')

    def work(self):
        print('训练做一些社会工作')

class GoldDog(Dog,Train):  # 继承顺序, 后边的类中不能出现前面类中的方法名
    def __init__(self):
        super().__init__()  # 同名方法就近原则
        print('金毛 初始化完成')

    def daoMang(self):
        print('导盲任务')

goldDog = GoldDog()
goldDog.work()
goldDog.swim()
goldDog.daoMang()

# 尽量使用单继承,多继承中的类方法名尽量不要重复。

5.5多态

多态 对父类的方法进行重写

class LocalDog(Dog):
    def __init__(self):
        super().__init__()  #  非必须调用父类方法
        print('中华田园犬初始化完成')

    def swim(self):  # 重写swim 方法
        super().swim()
        print('游的不太好')

localDog = LocalDog()
localDog.swim()

5.6 抽象类

抽象类(python本身不支持) 指定一个类规范写法

from abc import ABCMeta,abstractmethod
 
class PaymentAbc(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money): pass

    @abstractmethod
    def func(self): pass

class AliPay(PaymentAbc):
    def pay(self,money):
        print('这里用支付宝付了 %s 块钱' % money )

    def func(self): # 支付宝中的其他方法,例如 查余额, 转账
        print('查余额/转账')


class WxPay(PaymentAbc):
    def pay(self, money):
        print('这里用微信支付了 %s 块钱' % money)

    def func(self):  # 支付宝中的其他方法,例如 查余额, 转账
        print('查余额/转账')

相关文章

  • 2018-03-10

    Python第二周学习总结 导读:这是python学习的第二周,在第二周,学习了大量的python基础,其中有字符...

  • Python网络爬虫与信息提取入门<6>

    Part 20 第二周内容导学 我们继续学习python网络爬虫与信息提取课程。上一周我们讲解了python的re...

  • Python 第二周

    列表 列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型...

  • python练习(2)

    python学习的第二周,这周学习继续学习python基础,主要是生成器、函数式编程、模块。部分练习如下: 下周将...

  • 数据挖掘小组学习记录——20190728-2

    这是跟着数据挖掘小组学习的第二周。主要内容是Python数据分析基础。包括:1.Python基础(安装、基本用法、...

  • Python之旅(第二周)

    学习之旅的第二周在懵懂中完结,函数的“恶心”程度已经让一个小白晕了头,细细回味一下,函数是数学的一种提现,但是自己...

  • Python高级第二周

    1,浅拷贝^浅拷贝是对一个对象的顶层拷贝^通俗的理解就是:拷贝了引用,并没有拷贝内容 2,深拷贝^深拷贝是对于一个...

  • python高级第二周

    一、私有化 xx :公开属性 _xx :模块内可以访问的属性这个的作用是该属性只能在当前模块中使用,出了模块及不能...

  • python第二周作业

    前几天的作业做了一直没发,今天一起发了,上一周和这一周的作业基本上只敲代码,感觉上姑且看得懂,但没有做深入的理解,...

  • 第二周python基础

    python是严格区分大小写的 编译器 = 计算机不能直接理解任何除了机器语言意外的语言,所以必须要把程序员所写的...

网友评论

      本文标题:Python 第二周

      本文链接:https://www.haomeiwen.com/subject/udozpdtx.html