python学习之基础

第一章 列表

1.1 定义

列表 --list --容器

有序,可变,支持索引

列表: 存储数据,支持的数据类型不少 字符串,数字,布尔值,列表,集合,元祖,字典,

#定义一个列表
lst = ["zz",123,True,"中国"] # 用逗号分隔的是一个元素

print(lst[0])
print(id(lst[0]))
# id获取对象的内存地址

1.2 增长

lst.append("111")  #追加(在列表的最后位置添加一个内容)

lst.insert(2,"sd")  #插入  之后尽可能不要使用(当数据量比较大的时候会影响效率)

lst.extend("可迭代的内容")  # 迭代追加 只在最后追加

1.3 删除

lst.pop()  # 默认删除最后一个
lst.pop(-1) #能够根据索引删除

lst.remove("dsb") # 移除 经过元素名字进行删除 
print(lst) #只能删除1个

#remove 删除所有,使用while循环
l=[9,6,5,6,6,7,8,9,6,0]
length=len(l)
x=0
while x < length:
    if l[x] == 6:
        l.remove(l[x])
        # del l[x]
        x -= 1
        length -= 1
    x += 1
print(l)
lst[-1][1][1][0]

del lst[0]  # 经过索引删除
del lst[0:3] # 经过切片删除
del lst[0:3:2] # 经过步长删除

lst.clear()  #清空

1.4 改

lst = ["zz",123,True,"中国"]

lst[1] = "123" #经过索引改

lst[1:2] = "12345" #经过切片改
print(lst)
# ['zz', '1', '2', '3', '4', '5', True, '中国']

lst[1:4] = 12,13,14,15  
print(lst)
['zz', 12, 13, 14, 15]

lst[1:4:2] = "12"
print(lst)  # 步长不为1的必须用一一对应,多一个也不行,少一个也不行
['zz', '1', True, '2']

1.5 查

for i in lst:
    print(i)

1.6 列表嵌套

取出88

l=[1,2,3,[3,5,[77,88]]]
print(l[-1][-1][1])
# 无论什么类型进行切片的时候获取都到都是源数据类型

第二章 元组

1. 定义

-- tuple
tu=(1,"12",[12,11])
有序,不可变,支持索引
元组用于存储一些比较重要的信息
元组在配置文件中会使用元组就是不可变的列表

2. 读取

#for 循环
for i in tu:
    print(i)

第三章 range

1. 定义

# range -- 范围
print(list(range(0,10)))  # 顾头不顾尾  
经常使用于与for循环

python3 中的range是一个可迭代对象 写得是怎样的打印的时候就是怎样
获取成列表:list(range(0,10)) 顾头不顾尾
python2 中的range返回的是一个列表
xrange和python3中的range是类似的

2. 用法

print(list(range(0,10,1))) #步长不写的时候默认为1  [0:10:1]
print(list(range(10,0,-1))) # [10:0:-1]
print(list(range(10))) #1  [:10]

3. 例题

使用for循环和range 打印 100 ~ 1
for i in range(100,0,-1):
    print(i

输入三次姓名退出
lst = []
flage = True
while flage:
    name = input("请输姓名:")
    lst.append(name)
    if len(lst) == 3:
        flage = False

print(lst)
#------------------------------------------
lst = []
for i in range(3):
    lst.append(input("请输入姓名:"))
print(lst)

4. 小题

lst = [1,2]
for i in lst:
    lst.append("alex")
    print(lst) # 循环打印lst中的内容 -- 此循环是死循环

lst = [1,2]
for i in lst:
    lst.append("alex")
print(lst)  # 死循环 -- 不会打印内容

lst = []
for i in range(5):
    lst.append([])
print(lst)  # [[],[],[],[],[]]

lst = [1,2]
lst[0] = lst
print(lst)  # [[...],2]

第四章 字典

1. 定义

字典 -- dist

字典:无序的,可变的数据类型

字典:用于存储数据,存储大量数据 字典要比列表快 将数据和数据之间进行关联

dic = {1:"zbb",2:True,3:"追梦NAN",4:"人生苦短",5:"我用python"}

字典的键(key):

​ 可哈希的(不可变得数据类型) -- 避免哈希冲突使用了 开放寻址法

​ 要求惟一 -- 若是有重复的后边值的将前面的值覆盖

字典的值(value):

​ 能够任意

2. 增长

dic["zz"] = 89  # 暴力添加

dic.setdefault("www",100) #去字典查询key,若是不存在执行添加,若是存在就不添加了

3. 删除

del dic["www"]    # 经过字典的键删除键值对

dic.pop("zz")  #经过字典的键进行删除键值对  返回值:返回的是被删除的值

dic.clear()   #清空

4. 改

dic["aaa"] = "djj" #有则改,无则加

dic.update(dic1)  #  update括号中的字典级别高于update前面的字典

5.查

for i in dic1:   # 循环获取的是字典中每一个键值对的键
    print(i)

print(dic.get("cx"))  # 经过键获取值,若是将不存在字典中返回None

print(dic["cx"])      # 经过键获取值,若是将不存在字典中报错

6.其余操做

print(dic1.keys())  # 高仿列表 -- dict_keys(['1', '5', '2']) 支持for循环 不支持索引

for i in dic1.keys():       # 获取字典中全部的键
    print(i)

print(list(dic1.values()))   # 获取字典中全部的值

#获取字典中全部的键和值 存放在一个高仿列表里的元组(元组第一个元素:键,第二元素:值)
print(dic.items())
for i in dic.items():
    print(i[0],i[1])
    
#dict_items([(1, 'zbb'), (2, True), (3, '追梦NAN'), (4, '人生苦短'), (5, '我用python')])
# 1 zbb
# 2 True
# 3 追梦NAN
# 4 人生苦短

7.解构

a,b=10,12

print(a) #10
print(b) #12

a,b = [1,2]  #a=1,b=2
a,b = (3,4)  #a=3,b=4
a,_,b = (3,4,5)
print(a,b)   # 等号后边的值和前面的变量名要一一对应 3,5

a = 10,12 #本质就是一个元组

a,b = "23"
print(a,b)  # 2 3

a,b = {"1":"a","2":"b"}
print(a,b)  #1, 2 显示的是key

for i in dic.items():
    print(i)  #每一个字边变成了元组
#(123, '123')
#(1, '122')

for k,v in dic.items():
    print(k,v)    # 获取每一个元素的键和值

8.嵌套

dic = {1001:["伦","杰"],
       1002:{"峰":{"妻":["饼"],"前":["熊大","熊二"],"章":"肉丝"}},
       1003:{"陈":["娇","萨","芝"]}}
print(dic[1002]["峰"]["妻"][0])

第五章 小数据池

缓存机制(驻留机制)

节省资源

== 判断两边内容是否相等

is判断基于内存地址进行判断

a = 0
b = 0
print(a==b)
print(a is b)
print(id(a))
print(id(b))

1.代码块

可以提升一些字符串，整数处理人物在时间和空间上的性能；须要值相同的字符串，整数的时候，直接从‘字典’中取出复用，避免频繁的建立和销毁，提高效率，节约内存。

一个文件,一个函数,一个类,一个模块,终端中每个行是一个代码块

知足代码块缓存机制

适用对象: int (float) ,str , bool

数字:
在同一代码块下 只要内容相同就采用相同的内存地址(-5之后就不是)
数字在作乘法的时候范围 -5 ~ 256 ****
数字在作乘法的时候不能使用浮点数
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
乘法的时候总长度不能超过python3.7 4096 ****
乘法的时候中文,特殊符号乘以1或0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址

2.小数据池

可以提升一些字符串，整数处理人物在时间和空间上的性能；须要值相同的字符串，整数的时候，直接从‘池’里拿来用，避免频繁的建立和销毁，提高效率，节约内存

数字: -5 ~ 256 ****
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
乘法的时候总长度不能超过3.7 4096 ****
乘法的时候中文,特殊符号乘以0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
小数据池的验证方法,必须脱离代码块才能进行验证
先执行代码块的规则,在执行小数据的规则 --(驻留机制)

第六章 深浅拷贝

1.浅拷贝

浅拷贝的时候只拷贝第一层元素
浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变
浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变
浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()  # 新开辟一个空间给lst1
lst[-1].append(7)

print(lst1)
print(lst)
# 浅拷贝的时候,只会开辟一个新的容器列表,其余元素使用的都是源列表中的元素

lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()  #  [1,2,3,4,[5,6,7,[8,9]],10]
lst.append(10)
print(lst)
print(lst1)

lst = [1,2,3,4,[5,6,7,[8,9]]]
lst1 = lst.copy()
lst1[-1][-1] = "56"
print(lst) # [1,2,3,4,[5,6,7,[8,9]]]
print(lst1) # ["56",2,3,4,[5,6,7,[8,9]]]

dic = {"alex":[1,2,3,[5,6]]}
dic1 = dic.copy()
dic["alex"][0] = "56"
print(dic)
print(dic1)
#####直接就是第二层

2.深拷贝

用法

import copy  #导入
空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间
lst = [1,2,3,[5,6,7]]
lst1 = copy.deepcopy(lst)  # 深拷贝
lst[-1][-2]=1
print(lst)
print(lst1)

怎么改都不变

第七章 集合

集合 --set

至关于没有值得字典 无序 --不支持索引

-- set() 空集合

做用:

​ 自然去重

lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))

定义:

s = {1,2,3,4,5}

1. 增

s.add("67")  #只能添加一个
s.update("今天")  # 迭代添加

2. 删除

print(s.pop())  # pop有返回值
s.remove(3)     # 指定元素删除
s.clear()         # 清空

3. 查

for i in {1,2,3}:
    print(i)

4. 其余操做

# s1 = {1,2,3,4,5,6,7}
# s2 = {5,6,7,1}
# print(s1 & s2)  # 交集
# print(s1 | s2)  # 并集
# print(s1 - s2)  # 差集
# print(s1 ^ s2)  # 反交集
# print(s1 > s2)  # 父集(超集)
# print(s1 < s2)  # 子集

# print(frozenset(s1))  # 冻结集合 更不经常使用
# dic = {frozenset(s1):1}
# print(dic)