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']()
运行结果: