Python基础4

71 阅读 0 评论 47 点赞

我是靠谱客的博主大方玫瑰，最近开发中收集的这篇文章主要介绍Python基础4，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

元组-tuple

#创建空元组
t=()
#创建一个只有一个值的元组
t=(1,)//t=1,
print(t)=>(1,)
#创建多个
t=(1,2,3)//t=1,2,3
print(t)=>(1,2,3)
#使用其他结构创建
l=[1,2,3]
t=tuple(l)
print(t)=>(1,2,3)

元组的特性

是序列表，有序
元组数据值可以访问，

不能修改，不能修改，不能修改

元组数据可以是任意类型
总之，list所有特性，除了可修改外，元组都具有
也就意味着，list具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等，一模一样
索引操作

t = (1,2,3,4,5)
print(t[4])=>5
    
#不能超标
print(t[5])=>error

# 切片可以超标
t2=t[2:100]
print(t2)=>(3,4,5)
# tuple 的不可修改，指的是内容的不可修改
#不能这样t[1]=100


#遍历
for i in t:
    print(i)


#index:求制定元素在元组中的索引位置
print(t.index(3))=>2

两个变量交换值

 a=1
 b=3
 a,b=b,a
 print(a)=>3
 print(b)=>1

集合-set

s = set()
print(s)=>set()
s={1,2,3,4,5,6,7}
#不能只是用大括号定义，则定义的是一个dict类型
d={}#为字典dict类型

集合的特征

集合内数据无序，即无法使用索引和分片
集合内部数据元素具有唯一性，可以用来排除重复数据
集合内的数据，str, int, float, tuple,冰冻集合等，即内部只能放置可哈希数据

  # 多循环的集合内涵
    s1 = {1,2,3,4}
    s2 = {"i", "love", "you"}
    s = {m*n for m in s2 for n in s1 if n ==2}
print(s)=>['ii','lovelove','youyou'}


# add：向集合内添加元素
s = {1}
s.add(334)
print(s)=>{1,334}


# copy:拷贝



# remove:移除制定的值，直接改变原有值，如果要删除的值不存在，报错
s={1,2,3,4,5}
s.remove(4)
print(s)=>{1,2,3,5}
# discard:移除集合中指定的值，跟ｒｅｍｖｏｅ一样，但是如果要删除的不存在话，不报错

pop 随机移除一个元素,假随机，内定有一定规律

  s = {8,2,3,4,5,6,7}
    d = s.pop()
    print(d)=>2
    print(s)=>{3,4,5,6,7,8}

集合函数

#intersection: 交集
# difference:差集
# union: 并集
# issubset: 检查一个集合是否为另一个子集
# issuperset: 检查一个集合是否为另一个超集
s1 = {1,2,3,4,5,6}
s2 = {5,6,7,8,9}
s_1 = s1.intersection(s2)
print(s_1)=>{5,6}
s_2 = s1.difference(s2)
print(s_2)=>{1,2,3,4}
s_3 = s1.issubset(s2)
print(s_3)=>False

s_1=s1-s2
print(s_1)=>{1,2,3,4}
s_2=s1+s2 
print(s_2)=>{1,2,3,4,5,6,7,8,9}

frozen set:冰冻集合
并冻和就是不可以进行任何修改的集合

dict字典

字典是一种组合数据，没有顺序的组合数据，数据以键值对形式出现

 # 字典的创建
# 创建空字典
d = {}
//d=dict()
print(d)=>{}
d = {"one":1, "two":2, "three":3}
//d = dict({"one":1, "two":2, "three":3})
//d = dict(one=1, two=2, three=3)
//d = dict( [("one",1), ("two",2), ("three",3)])
print(d)=>{'one': 1, 'two': 2, 'three': 3}

字典的特征

字典是序列类型，但是是无序序列，所以没有分片和索引
字典中的数据每个都有键值对组成，即kv对
key: 必须是可哈希的值，比如int,string,float,tuple, 但是，list,set,dict 不行
value: 任何值

# 访问数据
d = {"one":1, "two":2, "three":3}
# 注意访问格式
# 中括号内是键值
print(d["one"])=>1
d["one"] = "eins"
print(d)=>{'one': 'eins', 'two': 2, 'three': 3}
# 删除某个操作
# 使用del操作
del d["one"]
print(d)=>{'two': 2, 'three': 3}

#成员检测检测的是key内容

  d = {"one":1, "two":2, "three":3}
    if 2 in d:
        print("value")
    if "two" in d:
        print("key")
    if ("two",2) in d:
        print("kv")
    =>key

遍历

d = {"one":1, "two":2, "three":3}
# 使用for循环，直接按key值访问
for k in d:
    print(k,d[k])=>one 1 two 2 three 3
    
# 上述代码可以改写成如下
for k in d.keys():
    print(k,d[k])=>one 1 two 2 three 3
    
# 只访问字典的值
for v in d.values():
    print(v)=>1 2 3
    
# 注意以下特殊用法
for k,v in d.items():
    print(k,'--',v)


# str(字典): 返回字典的字符串格式
d = {"one":1, "two":2, "three":3}
print(str(d))=>{'one': 1, 'two': 2, 'three': 3}


# items: 返回字典的键值对组成的元组格式
print(d.items())=>dict_items([('one', 1), ('two', 2), ('three', 3)])
# keys:返回字典的键组成的一个结构
print(d.keys())=>dict_keys(['one', 'two', 'three'])
# values: 同理，一个可迭代的结构
print(d.values())=>dict_values([1, 2, 3])
# get: 根据制定键返回相应的值， 好处是，可以设置默认值,找到就返回values，找不到就返回默认值
print(d.get("one", 100))=>1
print(d.get("one333", 100))=>100


# fromkeys: 使用指定的序列作为键，使用一个值作为字典的所有的键的值
l = ["eins", "zwei", "drei"]
# 注意fromkeys两个参数的类型
# 注意fromkeys的调用主体
d = dict.fromkeys(l, "hahahahahah")
print(d)=>{'eins': 'hahahahahah', 'zwei': 'hahahahahah', 'drei': 'hahahahahah'}