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>函数多个返回值默认会被组织为元组

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

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

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

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


# 第一个学生的姓名、年龄分别是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"])
# 如何查看字典的key
# 1>方式1：遍历
for tmp in d1:
    print(tmp)

# 2>方式2
print("输出所有的key值",list(d1.keys()))
print("输出所有的value值",list(d1.values()))

# dict.item会将每一个键值对组织成元组的形式
for tmp in d1.items():
    print(tmp)

# 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)
# 如何不覆盖的增加
# 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)

# 借助dict生成字典
# 列表的嵌套[[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)))

# 五个学生 姓名和年龄 有多少同学的年龄>=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)


# 将字典转换为列表或元组;仅能获取所有的key值
d1={
    
    "name":"AA","age":20}
print(list(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数字  输出其中的奇数

l1 = []
for i in range(1, 21):
    if i % 2 == 1:
        l1.append(i)
print(l1)

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进行互换
d1 = {
    
    "name": "zs", "age": 20}
d2 = {
    
    }
for k, v in d1.items():
    d2[v] = k

print(d2)

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))

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))

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

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

print(list(map(f, l2)))

# 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)))

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

print(max(d1, key=lambda x: x["name"]))

模块

"""
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("实例化对象时，自动调用该方法，这是初始化函数")
        self.r = r

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

# 实例化对象
c1 = Circle()
# 通过对象名调用函数。对象名.函数名
c1.area()

# 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()

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


# 封装
# 通过在属性 方法前增加两个下划线---实现私有的机制
class Person1:
    def __init__(self,name="zz",age=20):
        self.__name=name
        self.age=age
    def show_info(self):
        print("姓名是{}，年龄是{}".format(self.__name,self.age))
p1=Person1()
print(p1.age)