Python 元组、列表、循环、匿名函数、全局变量于局部变量、类和对象、模块的引用 7.21

元组类型

"""
    元组类型：用()表示，类型名 Tuple，类似于列表，但是元组的元素不可修改
    元组元素可以是 任意类型
"""
# t = () #空元组没有意义
t = (1, 8988, "yuan", [12, 5, 6])
print(t[1], t[1: 3])
t[-1][1] = 9  # 因为5不是元组的直接元素，但可以修改元组中列表的元素
print(t)

列表类型

"""
    列表：用[]表示，类型名list
    类似C语言的数组，但是列表元素可以是任意类型
"""
l1 = []  # 定义一个空列表
l2 = [1, 3.14, "omen", [2, 3, 4]]
print(l2)
l3 = [l1, l2]
print(l3)

"""
    列表元素的索引访问：[下标] , 与字符串元素索引一致
    元素访问：[下标]
"""
# 列表元素的访问
print(l2[1], l2[-1], l2[-1][-1], l2[-2][-2])

"""
    列表元素的切片：[start:stop:step)
"""
print(l2[1:3], l2[-1][1:])

# 列表元素的修改
l2[1] = 314
print(l2)
# 不支持字符串str的修改 l2[-2][-2] = 'l'

"""
    列表常用的函数
"""
l4 = []
l4.append(1)  # append() : 在列表末尾追加元素
l4.append(9879.4)
l4.append("second")
l4.insert(1, "third")  # insert() : 在指定位置中添加数据
print(l4)

循环

a, b, c = 6, 7, 8
while a < b:
    print(a)

buf = [1, 2, 3, 4, 5, 6]
for i in buf:
    print(i)

函数的定义

"""
    函数定义
    def函数名(<形参列表>):
        代码

    函数调用
       c = 函数名(<实参列表>)

    函数参数
        函数名(a,b)

    函数返回值
        return 返回值
"""


def myfun(a, b):
    a += 1
    return a + b


def myfun1(l1, l2):
    l1.pop(-1)  # 删除列表最后一个元素
    return l1 + l2


a, b = 100, 200
c = myfun(a, b)  # 函数的调用
print(a, c)  # a为数字类型，是不可变的

l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = myfun1(l1, l2)  # 函数的调用
print(l1, l3)  # l1是列表类型，元素值可变

匿名函数

"""
    匿名函数： 也就是lambda表达式：没有函数名、没有函数体
    只能在lambda表达式中封装有限的逻辑进去

    语法结构：
        lambda arg1, arg2 :expression 函数体
        注意：
            arg1：函数形参1
            arg2：函数形参2
            expression：函数返回值
    lambda表达式使用方法：
        c = (lambda arg1, arg2:expression)(arg1,arg2)
"""


def func(a, b):
    return a + b


x, y = 12, 13
# c = func(x, y)
c = (lambda a, b: a + b)(x, y)
print(c)

# def swap(x, y):
#     return y, x
# x, y = swap(x, y)

# 当返回多个数据时用元组()的方式返回，元组的元素一一对应
x, y = (lambda x, y: (y, x))(x, y)  # lambda表达式直接使用
print(x, y)

xx = lambda a, b: (b, a)  # lambda表达式间接使用
x, y = xx(x, y)
print(x, y)

"""
    列表推导式
"""
l1 = []
for i in range(1, 11):
    l1.append(i)
print(l1)

# 定义列表l2，元素为i，i满足for循环中i的取值
l2 = [i for i in range(1, 11, 2)]
print(l2)
# 将0~100之间的偶数存入列表中
l3 = [a for a in range(0, 101) if a % 2 == 0]
print(l3)

l4 = (23, 11, 434, 44, 6767, 78)
l1 = [i for i in l4 if i % 2 == 1]  # 将l4列表中的奇数存入到l1之中
print(l1)

"""
    内置函数
    sorted()---> sort() 内置函数可结合lambda表达式
    map()
"""
l1 = [2, 1, 4, 5, 7, 6]
# sorted(arg1, key=, reverse=): 默认按照reverse对 arg1进行升序排序， 返回排序的结果
# reverse=True 表示降序排序
l2 = sorted(l1, reverse=True)
print(l2)

l1.sort(reverse=False)
print(l1)

l3 = [('a', 4), ('b', 3), ('d', 1), ('c', 2)]
# key排序的依据，在表达式中 x会取到列表每一个元素，lambda返回x[0]代表列表中 的字符串数据
l2 = sorted(l3, key=lambda x: x[0], reverse=True)
print(l2)

l3.sort(key=lambda x: x[1])
print(l3)

# def sq(x):
#     return x ** 2


# map(a, b)：将b中的数据带入a中进行计算，返回 计算后数据的首地址
# add = map(sq, [i for i in range(10)])
add = map(lambda x: x ** 2, [i for i in range(10)])
print(add)
print(list(add))
print([x**2 for x in range(10)])

全局变量和局部变量

a = 13


def func():
    global a # 说明a为全局变量a
    a = 14


func()  # a = 14是局部变量
print(a)

a = 15
print(a)

类和对象

"""
class Demo:  # 定义一个类
    def printMsg(self):
        print("-------")


# 对于类属性的无中生有
obj = Demo()       # 定义一个类对象
obj.name = "张三"  # 访问类中的属性（成员变量）,该属性只会属于obj对象
obj.age = 19
print(obj.name, obj.age, obj.printMsg())

obj1 = Demo()
# obj1 = obj
# print(obj1.name)  # 错误，Demo类中没有 name属性
"""


class Student:
    # __init__(self): 魔法方法，类似于C++的构造函数，self：类似于this指针
    def __init__(self, n, a, s):
        self.name = n  # 通过self访问类的成员变量，没有的就自动添加成为成员
        self.age = a
        self.__sex = s

    # __del__ :魔法方法，类似于C++的析构函数
    def __del__(self):
        print("del success", self.name)

    def changeSex(self, s):
        self.__sex = s  # 定义私有属性，以__开头

    def getSex(self):
        return self.__sex


stu1 = Student("张三", 18, "男")
print(stu1.name, stu1.age, stu1.getSex())
stu2 = stu1
print(stu2.name)
stu3 = Student("kunkun", 20, "男")
print(stu3.name, stu3.age, stu3.getSex())
stu3.changeSex("woman")
print(stu3.getSex())

模块的引用

import Mymodel
import Mymodel as m

"""
    模块的加载及使用方法：
    1.直接导入整个模块，模块名就是py文件名
        import ModelName
        使用时：必须指定使用的是哪个模块中的哪个 变量、函数
            ModelName.name
        缺点：
            使用时都需要给定模块名，很麻烦
    2.导入模块，并重命名
        import ModelName as name
    3.从模块中导入需要使用的变量、函数，当前代码中使用的同名变量或函数都将是导入的
        from ModelName import name
    4.从模块中 导入所有的变量或函数
        from ModelName import *
        缺点：
            太占提及
"""
print(Mymodel.result, Mymodel.l1)
print(Mymodel.add(1, 2), Mymodel.sub(3, 2))
print(m.l1)

from Mymodel import l1, sub

print(l1)
print(sub(23, 11))

from Mymodel import *
print(result)
"""
    从pack包的Model模块中导入add函数
    import pack.model, pack.model2
    from pack.model import add
"""
import pack.model, pack.model2
# from pack.model import add
print(pack.model2.str1)
print(pack.model.add(1, 100))