python基础 | 常用数据结构：变量定义赋值，基础数据类型（number、string（单双引号）、boolean），复合数据类型（dict、list、set、tuple），嵌套引用

1、变量定义赋值

1、变量只是一个盒子，里面可以放 不同的数据，里面存放的是 引用地址
空对象不代表没有对象

2、变量名字是英文字母的组合（字母组合就识别为 变量名），不能以 数字开头，不能跟系统保留字重名

3、变量可以 多重赋值 比如：a, b = 1, 2 就等价于

a = 1 
b = 2

以及 连续赋值 比如：a = b = 1 就等价于

a = 1
b = 1

1.1 空间分配

所有数据类型 都是一个对象，分配空间后，把引用地址(标签)，存放在变量里

str1 = "ivan";
str2 = str1;    #//赋值是 引用的拷贝(引用是指向实体的地址)
print(id(str1)) #//id() 是查看对象的存储地址
print(id(str2))
print('str1 = ' + str1);  
print('str2 = ' + str2); 	
str1 = "yzg";
print(id(str1))
print(id(str2))

运行结果

box = ‘房子’

内核空间为高位空间
将字符串"房子"二进制 分配到 共享区；box变量就只有4个字节（32位机）
这个在共享区的二进制数据 有个地址编号，box里面放的是 这个地址编号（指向这个房子，引用地址（包括 数值，字符串，列表，字典等））

再执行 box = [‘a’, ‘b’] box里面存新的引用地址，指向这个列表

再执行 a = box 把box里面的 引用地址 复制到 a里面，这样box和a都指向了同一个内存实体，这个内存实体 指向那个列表存放的空间

再执行

a[2]里面存的是 actor所存的 引用地址，box[2][‘name’] 就是 ‘赵丽颖’

2、基础数据类型

2.1 number: 数字

数字(整形 浮点型（float） 复数（complex））

a,b,c = 10,3.14,1+2j  
print(a,b,c)
print(a+c) 
print(c,type(c))

运行结果

2.2 字符串（string）

单双引号都一样

str = 'hello baby'
print(str,str[1],str[2:4],str[6:]) // 前闭后开，像列表一样访问
name="good" 
print(str+name) // 拼接

运行结果

字符串不支持 对字符的修改

运行结果

2.2.1 声明字符串

# 声明字符串
str1 = 'Hello World!'
print('声明字符串.....')
print(str1)

运行结果：
声明字符串…
Hello World!

2.2.2 访问字符内容

print('访问字符内容.....')
print("str1[0]: ", str1[0])
print("str2[1:5]: ", str1[1:5])

运行结果：
访问字符内容…
str1[0]: H
str2[1:5]: ello

注意 1：5 是 第1~4个元素

2.2.3 字符串的操作（包含合并，复制，转义，是否在集合中）

print('字符串操作符.....')
a = "Hello"
b = "Python"

print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])

if ("H" in a):
    print("H 在变量 a 中")
else:
    print("H 不在变量 a 中")

if ("M" not in a):
    print("M 不在变量 a 中")
else:
    print("M 在变量 a 中")

print(r'\n')
print(R'\n')

运行结果：
字符串操作符…
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

2.2.4 字符串格式化

print('字符串格式化.....')
print("My name is %s and weight is %d kg!" % ('Asher Gu', 90))

print("formart method call:My name is {name} and weight is {weight} kg!".format(
    name="Asher Gu", weight=90))

运行结果：
My name is Asher Gu and weight is 90 kg!
formart method call:My name is Asher Gu and weight is 90 kg!

三引号：

'''
python 中三引号可以将复杂的字符串进⾏复制， python 三引号允许⼀个字符串跨多⾏，字符
串中可以包含换⾏符、制表符以及其他特殊字符。
'''

print('三引号.....')
hi = '''hi
i am Asher Gu'''
print(hi)

运行结果：
三引号…
hi
i am Asher Gu

附：Python中单引号，双引号的区别

总结自 Python中单引号，双引号，3个单引号及3个双引号的区别

单引号和双引号都可以用来表示一个字符串，没有区别

但是 原来的字符串中有一个’，而Python又允许使用单引号’ '来表示字符串，所以字符串中间的’必须用转移字符\才可以，用双引号会方便

str4 = 'We all know that \'A\' and \'B\' are two capital letters.'
str4_ = "We all know that 'A' and 'B' are two capital letters."

如果字符串中有双引号，为了避免使用转义符，你可以使用单引号来定义这个字符串。比如：

str5 = 'The teacher said: "Practice makes perfect" is a very famous proverb.'

会认为你字符串里面的双引号" "是普通字符，从而不需要转义

2.3 boolean:布尔值(逻辑判断)

ret = 2>1;
print(ret); 
ret =False;
if(ret):# 1 true 0 false 空字符串 false
  print('this is true');
else:
  print('this is false');

运行结果

3、复合数据类型

3.1 字典（dict）

字典是一个key-value的键值对，可以通过key取value（相比于列表 不至于用下标访问）

3.1.1 初始化字典

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict = {
	'Name': 'Zara', 
	'Age': 7, 
	'Class': 'First'
}

print("dict['Name']: ", dict['Name'])
print("dict['Age']: ", dict['Age'])

运行结果：
dict[‘Name’]: Zara
dict[‘Age’]: 7

3.1.2 修改字典键中的值

# 修改值
print("修改前:", dict['Age'])
dict['Age'] = 8  
print("修改后:", dict['Age'])
print("\n\n")

运行结果：
修改前: 7
修改后: 8

3.1.3 删除字典中的元素 / 整个字典

# 删除
del dict['Age']  # 删除键是'Name'的条目
# print("dict['Age']: ", dict['Age'])#引发异常，被删了
dict.clear()    # 清空词典所有条目
print(dict)
del dict      # 删除词典
print(dict)

运行结果：
{}
<class ‘dict’>

3.1.4 添加元素

obj={}  # 定义空的字典对象
obj['name']='yzg'
obj['age']=28
print(obj['name'],type(obj))

运行结果

3.1.5 字典的赋值

跟 列表的赋值相同

man={'name':'ivan','age':30}
print(man)
obj={}
obj['name']='yzg'
obj['age']=28
print(obj['name'],type(obj));
man = obj # 原来的man {'name':'ivan','age':30} 就被回收了
obj['age'] =10
print(man) # 一起变的

运行结果：

3.2 列表（list）

列表的每个元素都分配⼀个数字-----它的位置，或索引，第⼀个索引是 0 ，第⼆个索引是 1 ，依此类推
列表的数据项不需要具有相同的类型，但是可以 随机存取（可以自由取，自由改）

列表各项操作和数组很像，升级版的数组，列表中的元素可以是任意类型，甚至是 函数名 / 列表

运行结果

函数记录地址 可以直接加括号调用 train[2]()等价于 gogo()

3.2.1 创建列表

# 创建list
print("创建list.......")
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
print(max(list2))

print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])
print("\n\n")

运行结果：
创建list…
5
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]

注意1：5 的意思是1~4元素，[1, 5)

a2=[[2,3,4],[5,6,7],[8,9,10]] # 创建多维列表
print(a2[1][2])
a2[2] = 'ivan'
print(a2)

运行结果：

3.2.2 更新列表（修改 / 增加 / 插入列表中的值）

# 更新
print("更新list.......")
print("索引 2 的值: ")
print(list1[2])
list1[2] = 2001
print("索引2更新后的值为 : ")
print(list1[2])

运行结果：
更新list…
索引 2 的值:
1997
索引2更新后的值为 :
2001

增加元素：不支持直接利用下标增加元素

a = [2,5,9]
print(a)
a.append(9)      # 从尾部添加 (append是列表对象内置的方法函数)
print(a)
a.extend(['lili',9]) # 从尾部添加多个元素
print(a)

运行结果：

插入元素：

a.insert(1, 'i')  # 插入指定位置 1号位的前面
print(a);
a.insert(-2, '-i') # 倒数第二号位的前面
print(a);

3.2.3 删除列表元素

# 删除指定位置的元素
print("删除list.......")
print("删除索引2 处的值之前: ")
print(list1)
del (list1[2])
print("删除索引2 处的值之后: \n", list1)

运行结果：
删除list…
删除索引处的值之前:
[‘physics’, ‘chemistry’, 2001, 2000]
删除索引处的值之后:
[‘physics’, ‘chemistry’, 2000]

a.pop();          # 从尾部删除
print(a);
a.remove(5);      # 删除指定元素，5是元素值
print(a);

运行结果：

3.2.4 对列表的操作（合并，复制，截取，排序，倒置）

1、合并：

print('list1:', list1)
print('list2:', list2)

list4 = list1 + list2
print("list1 + list2 :", list4)

运行结果：
list1: [‘physics’, ‘chemistry’, 2000]
list2: [1, 2, 3, 4, 5]
list1 + list2 : [‘physics’, ‘chemistry’, 2000, 1, 2, 3, 4, 5]

2、复制：

list5 = ['hello']*4
print('[\'hello\']*4:', list5)

运行结果：
[‘hello’]*4: [‘hello’, ‘hello’, ‘hello’, ‘hello’]

3、截取

L = ['我', '想', '顺利!']
# 读取第二个元素
print(L[2])
# 读取倒数第二个元素
print(L[-2])
# 从第二个开始截取
print(L[1:])

运行结果：
顺利!
想
[‘想’, ‘顺利!’]
-1就是倒数第一个元素，-2就是倒数第二个元素

age = [13,10,15,50,22,60,20]
print(age[:3])
print(age[-2:])	# 倒二到最后
age[2:5]=3,3,3 # 2，3，4号位改
print(age)

4、排序和颠倒

# 排序
age = [13,10,15,50,22]
age.sort()         # 升序（直接在原列表上修改）
print(age)

stu = ['lili','ivan','ara11111','1ciga'];  
print(stu)  
stu.sort()         # 排序以第一个字符来排序（数字先排（排前面），排完后，按字母顺序）
print(stu)	

age.reverse()      # 颠倒（升序颠倒后就是降序）  
print(age)

3.2.5 列表的赋值

列表空间大，如果拷贝实体 浪费资源，这里=是 拷贝引用地址，所以 train变 list也变
[50,20,‘apple’] 是一个实体

train = [50,20,'apple']
print(train)
list = train
train[2] = 'tv'
print(train)
print(list)

i = 1
j = i
print(i)
i = 2
print(j)

运行结果：

3.2.6 不改变原列表的操作方法（查找，遍历，转换，运算）

查找
arr = [1, 2, 2,3] 
print(len(arr))       # 查看列表的长度
print(arr.count(2))   # 查看指定元素的个数
print(max(arr))       # 查看最大值的元素 
print(min(arr))       # 查看最小值的元素 
	
print(arr.index(2)) # 查找元素位置
print(2 in arr)	    # 有该元素吗

遍历
age = [40,20,10,30];
sum=0;
for v in age:
  sum+=v
print(sum);         # 输出100

转换
name=['ivan','yzg','lili'] 
print(" ".join(name))               # 列表元素之间加入分隔符" "，并转换为 字符串
list =[1,2,5,7,9]
print([v*10 for v in list if v>5])  # 列表推导
	
运算
age1 = [13,10,15]
age2 = [10,5]
age = age1+age2     # 拼接
nameage = name+age1
print(age)
print(age2*2)   
print(nameage*2)    
print(age1==age2)   # 判断两列表是否相等

ret = map(lambda x:x-2,[1,2,3]) # map映射会遍历列表元素进行转换（调用回调函数lambda）
print([v for v in ret])         # 因map后的对象不能通过print(ret)输出
# print(list(ret)) 				# 打印过一次之后ret就没东西了，输出是[]
详细解释见下

print(list(map(lambda x:x-2,[1,2,3])))# 是等价的，之前不能使用list作为列表的名字，不然会报错

ret = map(lambda x,y:x-y,age1,age2)   # 相减(通过map实现）
print([v for v in ret]) 

map() 函数返回一个 迭代器，它会根据指定的函数对 可迭代对象中的每个元素进行映射。当你对这个迭代器进行迭代后，它会 消耗掉 其中的元素。因此，当 对 ret 迭代器进行迭代后，它就会变为空，再次对其进行迭代时，不会再返回任何元素

如果 想要多次使用 ret 迭代器的结果，你可以将其 转换为列表，然后多次使用 这个列表：

ret = map(lambda x: x-2, [1, 2, 3]) 
ret_list = list(ret)
print([v for v in ret_list])  # 输出：[-1, 0, 1]
print(ret_list)  # 输出：[-1, 0, 1]

运行结果：

查找

转换

运算

例子：自己实现map函数，使用 回调函数 实现

 = [1,2,3]
def callback(x):
    return x-2
def map(callback_tmp, list):
    res = []
    for i in list:
        res.append(callback_tmp(i))
    return res

print(map(callback, a))

运行结果：

3.3 集合（set）

部分总结自：
Python的set集合详解 知乎

集合是一个无序不重复元素的集。基本功能包括各种操作和消除重复元素
把不同元素放在⼀起就组成了集合，集合的成员被称为集合元素
Python 的集合和数学的结合在概念和操作上基本相同，但是不可以通过下标随机取（因为无序）
Python 提供了两种集合：可变集合和不可变集合

3.3.1 集合的初始化

s1 = set('good good study')
s2 = set([1, 2, 3, 4, 5])
s3 = frozenset("ggs")  # 不可变集合

print(type(s1))
print(type(s3))
print(s2)

运行结果：
<class ‘set’>
<class ‘frozenset’>
{1, 2, 3, 4, 5}

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)
print('banana' in basket) # 查找是否在集合中，类型也必须匹配（50与'50'不同，但50与50.0相同）

运行结果：

set集合类需要的参数必须是迭代器类型的，如：序列、字典等，然后转换成无序不重复的元素集。由于集合是不重复的，所以可以对字符串、列表、元组进行去重操作

s4 = set({'Name': 'Zara', 'Age': 7, 'Class': 'First'})
print(s4)

运行结果：
{‘Name’, ‘Class’, ‘Age’}

可以发现当参数为字典时，只有key被放进了集合

集合⽆序，⽆重复元素：

# 集合⽆序，⽆重复元素
# 输出集合内容
s1 = set('good good study')
s3 = frozenset("ggs")
print(s1)
for item in s3:
    print(item)

运行结果：
{‘s’, ‘o’, ‘y’, ‘u’, ’ ', ‘t’, ‘d’, ‘g’}
s
g

可以看出所有字母都去重了，包括空格

3.3.2 集合元素更新（添加删除）

s2 = set([1, 2, 3, 3, 4, 5])
print("原始数据：", s2)
s2.add("j")
print("添加数据后：", s2)
s2.remove(3)
print("删除数据后：", s2)
s2.update([6, 7, 8, 9])
print("update数据后：", s2)

运行结果：
原始数据： {1, 2, 3, 4, 5}
添加数据后： {1, 2, 3, 4, 5, ‘j’}
删除数据后： {1, 2, 4, 5, ‘j’}
update数据后： {1, 2, 4, 5, 6, 7, 8, 9, ‘j’}

集合的添加有两种方式，分别是add和update。但是它们在添加元素时是有区别的：
1、add()方法
把要传入的元素作为一个整体添加到集合中，如：

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.add('two')
>>> s
{'e', 'two', 'o', 'n'}

2、update()方法
是把要传入的元素拆分成单个字符，存于集合中，并去掉重复的字符。可以一次添加多个值，如：

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.update('two')
>>> s
{'e', 'n', 't', 'w', 'o'}

3.3.3 对集合的交并补

# 求并集
s1 = set('abcdde')
s2 = set([1, 2, 3, 4, 5])
s4 = s1 | s2
print("s1|s2", s4)

# 求交集
print("s1&s2", s1 & s2)

# 求差集
print("s1-s2", s1 - s2)
print("s1 dif  s2", s1.difference(s2))

运行结果：
s1|s2 {1, 2, ‘e’, ‘c’, 3, 4, 5, ‘b’, ‘a’, ‘d’}
s1&s2 set()
s1-s2 {‘e’, ‘c’, ‘b’, ‘a’, ‘d’}
s1 dif s2 {‘e’, ‘c’, ‘b’, ‘a’, ‘d’}

s1.difference(s2)这种不同指的是集合s2相对于集合s1，不同的地方，也就是所有在集合s1中，而不在集合s2中的元素组成的新集合

3.4 元组（tuple）

Python 的元组与列表类似，不同之处在于元组的元素不能修改（只读的列表）
元组使⽤⼩括号，列表使⽤⽅括号
元组创建很简单，只需要在括号中添加元素，并使⽤逗号隔开即可,元组的各项操作和列表类似
元组中只包含一个元素时，需要在元素后面添加逗号

3.4.1 元组的初始化

tup0 = ()  # 空元组
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = ("a", "b", "c", "d")
tup4 = (50,)  # 元组中只包含一个元素时，需要在元素后面添加逗号

print("tup0: ", tup0)
print("tup1: ", tup1)
print("tup2[1:5]: ", tup2[1:5])

运行结果：
tup0: ()
tup1: (‘physics’, ‘chemistry’, 1997, 2000)
tup2[1:5]: (2, 3, 4, 5)

3.4.2 元组的操作

print(tup4*4)
print("tup4: ", tup4)
print(tup2+tup3) # 拼接（列表也是）不是对应位相加
print(tup1[1:])
print(tup1[-2])

运行结果：
(50, 50, 50, 50)
tup4: (50,)
(1, 2, 3, 4, 5, ‘a’, ‘b’, ‘c’, ‘d’)
(‘chemistry’, 1997, 2000)
1997

print(tuples[2.0])  #//报错：TypeError: tuple indices must be integers or slices, not float 
                    #原因时类型不匹配，需把2.0  转为int 用 int(2.0)

4、嵌套引用

比如 在列表里嵌套字典（在列表的某个下标空间里 放字典地址），然后 在字典里放元组

运行结果

可以自己设计 复杂的数据结构
函数名也是 引用地址

train = [50,20,'apple'];
train[1] ={'name':'lili','age':30}
print(train)


#//可把函数名，看成指向代码块的引用
def gogo():
    print("i can gogogo")
    
train[1]['teach']=gogo  
print(train)
train[1]['teach']()

运行结果：