python学习_day3---元组、字典、推导式、进阶函数、模块

一、元组

"""
字符串：不可修改的有序序列
list：可修改的有序序列
元组（tuple）：不可修改的有序序列

元组定义（元素1，元素2，元素3...）
元素可以为不同的数据类型
"""
# 元组定义
t1=(1,2,3,"zz",0.9,("哈哈","嘿嘿"))
print(type(t1))  #  <class 'tuple'>
print(t1)

# 空元组的定义
# 1>方式1
# t2=tuple()
# 2>方式2
t2=() #可以创建空元组
print(t2,type(t2))

# 只有一个元素的元组
t3=(1)
print(t3,type(t3))  # 1 <class 'int'>
t4=(1,)
print(t4,type(t4))  #(1,) <class 'tuple'>
t5=tuple("1")
print(t5,type(t5))  #('1',) <class 'tuple'>

# 列表和元组的转换
print(t1)
l1=list(t1)
new_t1=tuple(l1)
print(new_t1)

# 加法和乘法
t1=(None,)
print(t1*10)

# 增删改查--不可修改
# 查找--下标法 切片法[start,stop,step]
# 修改
t1=(1,2,3,"zz",0.9,["哈哈","嘿嘿"])
# t1[0]=100
# 如果元组中的元素 是一个列表，可以被修改
t1[-1].append("xixi")
print(t1) #(1, 2, 3, 'zz', 0.9, ['哈哈', '嘿嘿', 'xixi'])

# 元组的应用
# 1>格式化字符串输出 %
# 2>函数多个返回值默认会被组织为元组

# 元组的遍历
t1=(1,2,3,"zz",0.9,["哈哈","嘿嘿"])
for tmp in t1:
    print(tmp,end=" ")

#应用：赋值
t6=("张三",20)
name,age=t6
print(name,age) # 张三 20

t7=("张三",20,1,2,3,4,5)
name,*args=t7
print(name,args) # 张三 [20, 1, 2, 3, 4, 5]

# 应用：
t8=("AA","BB","KK","ZZ")
t9=(20,19,18,22)
# 枚举
for tmp in enumerate(t8):
    print(tmp)
"""
(0, 'AA')
(1, 'BB')
(2, 'KK')
(3, 'ZZ')
"""
# 打包 压缩，如果长度不一致，以短的为主
# for tmp in zip(t8,t9):
#     print(tmp)
for name,age in zip(t8,t9):
    print(name,age)
"""
AA 20
BB 19
KK 18
ZZ 22
"""

# 第一个学生的姓名、年龄分别是AA，20
# 第二个学生的姓名、年龄分别是BB，19
# ...
t8=("AA","BB","KK","ZZ")
t9=(20,19,18,22)
for tmp in enumerate(zip(t8,t9)):
    ind,info=tmp
    name,age=info
    print("第{}个学生的姓名是{},年龄是{}".format(ind,name,age))
"""
第0个学生的姓名是AA,年龄是20
第1个学生的姓名是BB,年龄是19
第2个学生的姓名是KK,年龄是18
第3个学生的姓名是ZZ,年龄是22
"""
t8=("AA","BB","KK","ZZ")
t9=(20,19,18)
for tmp in enumerate(zip(t8,t9)):
    ind,info=tmp
    name,age=info
    print("第{}个学生的姓名是{},年龄是{}".format(ind,name,age))
"""
第0个学生的姓名是AA,年龄是20
第1个学生的姓名是BB,年龄是19
第2个学生的姓名是KK,年龄是18
"""

二、字典

"""
字典:dict,可以修改，无序的序列
定义：{元素1，元素2，...}
定义：{key1:value1，key2:value2，...}
key值,不能重复
"""

# 定义
d1={"name":"AA","age":20}
print(d1,type(d1)) # {'name': 'AA', 'age': 20} <class 'dict'>

# 空字典
# 1>方式1
# d2=dict()
# 2>方式2
d2={}
print(d2,type(d2)) # {} <class 'dict'>

# 无序序列--无法通过下标法和切片法访问
d1={"name":"AA","age":20}
# print(d1[0]) ×
# 访问:字典名[key]
print(d1["name"]) # AA
# 如何查看字典的key
# 1>方式1：遍历
for tmp in d1:
    print(tmp)
"""
name
age
"""
# 2>方式2
print("输出所有的key值",list(d1.keys()))
print("输出所有的value值",list(d1.values()))
"""
输出所有的key值 ['name', 'age']
输出所有的value值 ['AA', 20]
"""
# dict.item会将每一个键值对组织成元组的形式
for tmp in d1.items():
    print(tmp)
"""
('name', 'AA')
('age', 20)
"""
# key和value取值限制
# key:字符串、数字、布尔、元组、（列表不能作为key值）
# key：只能使用不可修改的数据类型
# value:字符串、数字、布尔、元组、列表、字典
d2={"name":"AA","age":20}

# 增删改查
d2={"name":"AA","age":20,"hobby":{}}
# 1>增
# 如果增加的key值不存在就是增加操作，如果增加的key值存在就是修改操作
d2["call"]=135
d2["name"]="里斯"  #----修改的操作
print(d2) # {'name': '里斯', 'age': 20, 'hobby': {}, 'call': 135}
# 如何不覆盖的增加
# 1、判断新增key值是否存在字典中
if "电话" in d2:
    print("存在")
else:
    print("不存在")

print("电话" in d2)  #返回True或False

# 2>setdefault 如果key值不存在，就进行新增，否则不操作
d2.setdefault("电话","187")
print(d2)

# 2>删
# 目前字典：{'name': '里斯', 'age': 20, 'hobby': {}, 'call': 135, '电话': '187'}
# pop删除--需要指定key
d2.pop("hobby")
print(d2)
# popitem--在3.6/3.7版本前随机删除，在3.6/3.7版本之后删除最后一个
d2.popitem()
print(d2)

# 借助list生成字典
# 列表的嵌套[[k1,v1],[k2,v2],[k3,v3]...]
# 元组的嵌套((k1,v1)),(k2,v2),(k3,v3)...)
# 列表和元组结合的嵌套([k1,v1],[k2,v2],[k3,v3]...)
l1=[["name","张三"],["age",20]]
d3=dict(l1)
print(d3)
# ----把下列转成字典----
name=("AA","BB","KK","ZZ")
age=(20,19,18,22)
print(dict(zip(name,age)))
print(list(zip(name,age)))
"""
{'AA': 20, 'BB': 19, 'KK': 18, 'ZZ': 22}
[('AA', 20), ('BB', 19), ('KK', 18), ('ZZ', 22)]
"""

# 将字典转换为列表或元组;仅能获取所有的key值
d1={"name":"AA","age":20}
print(list(d1)) # ['name', 'age']

# 五个学生 姓名和年龄 有多少同学的年龄>=18
name=("AA","BB","KK","ZZ","CC")
age=(12,19,13,22,16)
d1=dict(zip(name,age))
print(d1)
for key in list(d1):
    if d1[key]<=18:
        d1.pop(key)
print(d1)

三、集合

"""
集合 set
可以修改的无序序列
无序、唯一、元素是确定的(元素必须为不可修改数据类型，所以不能有列表)
定义{元素1,元素2,...}
"""
# 创建集合
s1={1,2,3,4,5,3,2,1,"12",0.9,True,(12,13)}
print(s1,type(s1)) # {1, 2, 3, 4, 5} <class 'set'> 自动去重

# 空集合创建
s2=set()
# s2={} # ×，创建结果为字典

# 增
"""
add---增加一个元素
update---追加一个新的集合
"""
s3={"嘻嘻","呵呵","哈哈"}
print(s3) # 无序的，每次输出都会变化
s3.add("嘿嘿")
print(s3)
s3.update({"咯咯","噗噗","哈哈"})
print(s3)

# 删
s3={"嘻嘻","呵呵","哈哈"}
# s3.pop() # ----随机删除一个
# print(s3)
s3.remove("呵呵") # ----删除指定元素
print(s3)

# 集合最常用的形式
# 如果数据有大量重复，可将数据转换成集合的形式，再转换回去
list1=[1,1,1,12,2,3,4,5,5,6,1,1,3,4,5,6,6,7,7,81,1]
list2=list(set(list1))
print("数据去重后",list2)

四、推导式

"""
推导式：列表/元组的推导式
列表推导式，利用一定的条件 从 一个列表中生成一个新的列表
"""
# 1-20数字  输出其中的奇数
# 1>方法1
l1 = []
for i in range(1, 21):
    if i % 2 == 1:
        l1.append(i)
print(l1)

# 2>方法2
list1 = list(range(1, 21))
print(list1)
list2 = [i for i in list1 if i % 2 == 1]
print(list2)

# ["张三"，"李四", "王X五"]  取名字的姓
# ["张三"，"李四", "王X五"]  获得姓名的长度
l1=["张三","李四","王X五"]
print([i[0] for i in l1])
print([len(i) for i in l1])

# key和value进行互换
# 1>方法1
d1 = {"name": "zs", "age": 20}
d2 = {}
for k, v in d1.items():
    d2[v] = k
print(d2)
# 2>方法2
d3 = {v: k for k, v in d1.items()}
print(d3)

五、函数的进阶

def fun(a, name):
    a += 10
    name.append(a)

# a = 100
# name = []
# fun(a, name)
# print(a)
# print(name)

# 当传入的可变类型，函数内发生变化，会影响外部的值
# 内部作用域、全局作用域、内置作用域 ----就近原则
# a = "ZS"

def f():
    # a = 10
    # print(a)
    # abs(a)
    print(abs)

# f()

# 内置函数
# ① max函数.参数可以散列的值 或列表元组等迭代器
# 参数key，遍历得到元素 会经过key对应的函数。之后对处理后的结果求最大值
# print(max(1, 2, 4))
l1 = [1, 2, 3, 9, 0, "AA"]
print(max(l1, key=str)) # AA

d1 = [{"name": "a", "age": 20},
      {"name": "b", "age": 18},
      {"name": "c", "age": 16}]
      
def get_max(d1):
    return d1["age"]
    
print(max(d1, key=get_max)) # {'name': 'a', 'age': 20}

# map函数(fun, iter)
# 对可迭代对象每一个元素进行遍历，按照某函数进行运算，之后返回运行之后的结果
l2 = [1, 2, 3, 4]

def f(i):
    # 复杂操作
    return i ** 2

print(list(map(f, l2))) # [1, 4, 9, 16]

# filter 函数  过滤的 (fun, iter)
# 对可迭代对象每一个元素进行遍历， 按照某函数进行运算，返回True/False
# 返回True对应位置的元素

def f(i):
    if i % 2 == 0:
        return True
    else:
        return False

print(list(filter(f, l2)))  # [2, 4]

# 匿名函数
# lambda [参数] : 表达式
# lambad x :
# lambad x,y : max(x,y)

# lambda x : x%2
print(list(filter(lambda x: (x % 2) == 0, l2)))  # [2, 4]

l3 = [1, 2, 3, 4]
f = lambda x: x ** 2
print(list(map(f, l2))) # [1, 4, 9, 16]

d1 = [{"name": "a", "age": 20},
      {"name": "b", "age": 18},
      {"name": "c", "age": 16}]

print(max(d1, key=lambda x: x["name"])) # {'name': 'c', 'age': 16}

六、模块

"""
python中每一个文件 都是模块
导入模块：import 模块名字 [as 别名]
导入时 会将整个文件执行一遍
多次导入，仅执行一次
"""
# import my_module as m1
# import my_module

# 精准导入
# from 模块名 import 变量/函数名
name = "模块"
from my_module import name

print("-----", name)

print(name)

# 当前文件和模块中的 命名冲突时，调用方式为 就近原则

#my_module.py
name = "zz"

def f():
    print("模块内部")

print("结束----------")

七、面向对象

"""
面向对象 三大特性
多态、封装、继承

类和对象
"""
# 定义类
"""
class 类名:
    属性/变量的定义  通常在__init__()中定义
    方法/函数
"""
PI = 3.14

class Circle:
    # r = 10
    def __init__(self, r=10):
        print("实例化对象时，自动调用该方法，这是初始化函数")
        print("类中的self的id",id(self))
        self.r = r

    def area(self):
        print("面积是", PI * self.r * self.r)

# 实例化对象
c1 = Circle()
# 查看变量的内存地址 id(变量名/类名)
print("c1的内存地址",id(c1))
# 通过对象名调用函数。对象名.函数名
c1.area()
"""
实例化对象时，自动调用该方法，这是初始化函数
类中的self的id 2056813335072
c1的内存地址 2056813335072
面积是 314.0
"""
# 哪个对象在使用，self的地址就是谁
# 哪个对象调用方法或属性，self就是那个变量
c2 = Circle()
print("c2的内存地址",id(c2))
"""
实例化对象时，自动调用该方法，这是初始化函数
类中的self的id 2056813388752
c2的内存地址 2056813388752
"""

# 特殊方法:__函数名__
# __init__在实例化对象时自动调用
# __str__ 在打印对象时 自动调用该方法--必须有return语句
# __del__ 在对象销毁时自动调用
# __call__可以直接通过对象名加()调用--混淆了对象和函数之间的差距

# person类
# name age----属性
# show_info():----方法
# class Person
class Person:
    def __init__(self,name="zz",age=20):
        self.name=name
        self.age=age
    def show_info(self):
        print("姓名是{}，年龄是{}".format(self.name,self.age))
    def __str__(self):
        return "这是一个person类"
    def __del__(self):
        print("对象销毁时自动调用")
    def __call__(self, *args, **kwargs):
        print("可以直接通过对象名加()调用")
p1=Person()
# print(p1.name)
# p1.show_info()
p1() # 可以直接通过对象名加()调用
print(p1)