本站消息

站长简介/公众号


站长简介:高级软件工程师,曾在阿里云,每日优鲜从事全栈开发工作,利用周末时间开发出本站,欢迎关注我的微信公众号:程序员总部,程序员的家,探索程序员的人生之路!分享IT最新技术,关注行业最新动向,让你永不落伍。了解同行们的工资,生活工作中的酸甜苦辣,谋求程序员的最终出路!

  价值13000svip视频教程,python大神匠心打造,零基础python开发工程师视频教程全套,基础+进阶+项目实战,包含课件和源码

  出租广告位,需要合作请联系站长

+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

2020-12(10)

2021-01(38)

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

发布于2021-11-21 18:27     阅读(442)     评论(0)     点赞(21)     收藏(0)



元组

"""
字符串:不可修改的有序序列
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)

原文链接:https://blog.csdn.net/weixin_45800653/article/details/121407874







所属网站分类: 技术文章 > 博客

作者:74873487

链接:https://www.pythonheidong.com/blog/article/1082687/546b5f070dfcd34ddd10/

来源:python黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

21 0
收藏该文
已收藏

评论内容:(最多支持255个字符)