Hello World程序
[root@mysql ~]# python3
Python 3.6.5 (default, Jul 8 2018, 11:41:23)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-18)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello World!')
Hello World!
>>>
声明变量
变量名称定义的规则(即标识符):
做到变量名见名知意,普通变量名全部使用小写,“长量”变量名全部使用大写
- 变量名只能是字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- python中的关键字,即保留字,不能用作变量名。
Python中的保留关键字:全部是小写
and |
exec |
not |
assert |
finally |
or |
break |
for |
pass |
class |
from |
|
continue |
global |
raise |
def |
if |
return |
del |
import |
try |
elif |
in |
while |
else |
is |
with |
except |
lambda |
yield |
变量的赋值:
python是强类型语言,不需要对变量进行声明,第一次赋值时,变量的类型才会确定下来
>>> int_test = 123
>>> str_test = 'hello world!'
>>> print(int_test,str_test)
123 hello world!
注意:python中的字符串,无论何时都要使用引号引起来
python中的引用
python中有3种引用方式:单引号、双引号,三引号
单引号和双引号完全相同,没有任何区别,不像shell中不同
三引号:
示例:
>>> three_quo = '''
... hello world
... test for test
... am ok
... how are you?
... '''
>>> print(three_quo)
hello world
test for test
am ok
how are you?
>>>
可以看出,三引号中的内容在python中原样打印
预备知识
对象引用,python是面向对象的编程语言,python总一切皆对象,只有对象才有属性、方法、函数
将一个值赋给变量,称为变量对对象的引用,一旦进行了赋值,就可以通过变量来操作对象。
注意:变量是没有类型的概念的,类型是对象的一种属性,而不是变量,变量只是对对象的引用
del语句
del可以删除变量对对象的引用
del语句的语法是:
del var1[,var2[,var3[....,varN]]]
var1 = 1
var2 = 10
del var1,var2 #删除这两个引用
判断对象类型
函数:type(x), 返回x的类型,适用于所有类型的判断。
>>> type(int_test)
<class 'int'>
>>> type(str_test)
<class 'str'>
>>>
python核心数据类型
python中核心数据类型主要有5种:
Numbers(数字)、String(字符串)、List(列表)、Tuple(元组)、Dictionary(字典)
1、数字
数字属于不可变类型,不能够原位改变
python中有4种数字类型:
1)整型(python 3.x中已经将int和和long类型合并)
示例:
十进制:1010 , 99 , -217
十六进制:0x9a , 0X89 ( 0x , 0X 开头表示十六进制)
二进制:0b010,-0B101 ( 0b , 0B 开头表示二进制 )
八进制:0o123 , -0O456 ( 0o , 0O 开头是八进制 )
2)浮点型
python中的浮点数的数值范围和小数精度都存在限制,这种限制与在不同的计算机系统有关。
示例:
0.0 ,-77. ,-2.17
96e4 , 4.3e-3 , 9.6E5 ( 科学计数法 )
科学计数法使用 ‘e’ 或 ‘E’ 作为幂的符号,以10为基数
3)复数型
z = a + bj
a 是实数部分, b 是虚数部分,a和b都是浮点类型,虚数部分用 j 或 J 表示。
示例:
12.6 + 5j -7.4 - 8.3j
对于复数可以用 z.real来获得实部,z.imag来获得虚部。
上述3种数字类型存在一种逐渐“扩展”关系
整数 ——> 浮点数 ——> 复数
1.1 数字类型的转换
三种数字类型可以相互转换
函数:
int() : 把括号里的数转化为整型
float() : 把括号里的数转化为浮点型
complex() : 把括号里的数转化为复数
示例:
int(4.5) = 4 (直接去掉小数部分)
float(4) = 4.0 (直接增加小数部分)
complex(4) = 4 + 0j
complex(4.5) = 4.5 + 0j
1.2 数字类型的运算
即通过前面的运算符进行操作,数字最常用的操作符为数字运算操作符和比较运算操作符2种
>>> 1 + 5 * 6
31
>>> 1 <= 3 <= 5
True
>>>
2、字符串
字符串(String)是由数字、字母、下划线组成的一串字符
注意:
字符串是python中序列的一种
python中字符串无论何时都要位于引号中
字符串是编程语言中表示文本的数据类型(因此编程中操作文件时,如写入到文本中的都是字符串,从文本中读出来的也都是字符串)
一般记为:
s="a1a2···an"(n>=0)
python的字串序列有2种取值顺序:也就是后面要讲的分片操作
- 从左到右索引默认0(右侧第一个字符)开始的,最大范围是字符串长度减1
- 从右到左索引默认是从索引-1(左侧第一个字符)开始的,最大范围是字符串开头
- 如果头下表为空,表示从第一个字符开始,如果尾下标为空,表示最后一个字符的结尾
如果要实现从字符串中获取一段子字符串的话,可以使用变量[头下标:尾下标],就可以截取(分片)相应的字符串,其中下标可以是从0开始算起,可以是正数或负数,下标可以为空表示取到头或尾。
比如:
>>> s = 'ilovepython'
>>> s[0:3]
'ilo'
2.1 字符串的操作
2.1.1 索引、分片、连接、重复(这4个操作适用于python中所有的有序序列)
2.1.2、成员运算
2.1.3、字符串的拼接
字符串的join属性
join()函数
语法:'sep'.join(seq)
参数说明
sep:分隔符可以为空
seq要连接的元素序列(对象):字符串、列表、元组、字典
上面的语法即:以sep作为分隔符,将对象中的每个元素使用seq分隔符连接
返回值:返回一个以分隔符sep连接各个元素后生成的字符串
注意:只能连接字符串,不能连接数值,因此操作元组或字典时,其元素不能含有数值,否则否则会失败,如果嵌套的是子列表或字典时也会失败(没有位于引号中,不是字符串)
示例:
seq1_str =
'hello world!'
seq2_list = ['chian', '123','for']
seq3_tup = ('chian', '123',
'for')
seq4_dict = {'name':'jack', 'sex':'male', 'color':'red'}
print('+'.join(seq1_str))
print('+'.join(seq2_list))
print('+'.join(seq3_tup))
print('+'.join(seq4_dict))
2.1.4、字符串的其他内置方法
a = 'test\tchian123test{0},{name}-{age}'
print(a.count('t')) #统计字符串中t字符出现的次数
print(a.capitalize())
#字符串首字母大写
print(a.center(50,
'#')) #字符串两端各加50个#字符
print(a.ljust(50, '#')) #在字符串的右侧打印50个#字符
print(a.rjust(50, '#')) #在字符串的左侧打印50个#字符
print(a.endswith('st')) #判断字符串以什么结尾,返回Ture或false
print(a.startswith('t'))
#判断字符串以什么开头,返回Ture或false
print(a.expandtabs(tabsize=40)) #设定tab键为多长,即多少个空格
print(a.find('u')) #查找指定字符在字符串中第一次出现的索引,找不到返回-1
print(a.index('1'))
#类似find,如果找不到会报错
print(a.format('BOOL',name
= 'wang', age=31))
#格式化输出
c = 'test123test'
print(c.isalnum()) #判断字符串是不是字母数字混合,返回true或false
print('test'.isalpha())
#判断在字符串是不是字母,返回true或false
print('123'.isdecimal()) #判断字符串是不是十进制数字,返回true或false
print('1245'.isdigit()) #判断字符串是不是只含有数字字符,返回true或false
print('123.123'.isnumeric()) #同上,判断每个字符是否都是数字字符,返回true或false
print('2_test'.isidentifier())
#判断某个标识符是否合法,返回true或false
print('ABC'.islower())
#所有字母是否都是小写,返回true或false
print('ABC'.isupper())
#所有字母是否都是大写,返回true或false
print('abc'.upper()) #转换成大写字母
print('ABC'.lower())
#转换成小写字母
print('AbC'.swapcase())
#大小写互相转换
print('to be or not to be'.title()) #将字符串转换成标题形式(每个单词首字母大写)
print('abc'.isspace())
#是否是空格
print('abc'.isprintable())
#是否可打印
print('My Title'.istitle())
#是否是标题(标题即每个单词首字母大写)
print(' test
\n'.strip()) #将字符串开头和结尾的空白字符去除(空格、换行符等)
print(' test \n'.lstrip()) #将字符串左侧的空白字符去除
print('\n test '.rstrip()) #将字符串右侧的空白字符去除
print('abcb'.replace('b','T',1)) #将字符串中指定部分替换,默认全部替换,最后一个参数指定替换次数
print('to be or not to be'.rfind('b')) #从左向右侧开始查找指定字符的索引
print('to be or not to be'.split('or')) #将字符串已指定的分隔符分隔层层列表,将字符串转换为列表,列表转换为字符串使用join
print('to be or not to be'.rsplit('o'))
print('abc'.zfill(30)) #字符串左侧填充多少个0
b = 'testchian123test,{name}-{age}'
print(b.format_map({'name':'wang','age':31})) #类似format方法,指定参数时,必须以字典形式指定
2.2.5 格式化输出
3、列表
List(列表)是Python中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串,甚至可以包含列表(即嵌套),列表可以嵌套其它任何类型。
列表用[ ]标识,是python最通用的复合数据类型。
列表中值的切割也可以用到变量[头下标:尾下标],就可以截取相应的列表,从左到右索引默认0开始,从右到左索引默认-1开始,下标可以为空表示取到头或尾。
加号+是列表连接运算符,星号*是重复操作。
列表操作:
3.1、分片(查)
3.2、增加元素
append方法,在最后插入一个元素
insert方法,在任意指定的索引位置插入1个元素
3.3、修改
列表和字典可以原位修改,而数字、字符串、元组属于不可变对象,不能原位修改
3.4、删除
remove 指定元素删除
pop 指定索引删除,如果不指定索引值,默认删除最后一个元素
clear 清空列表,列表仍然存在
del 即可删除指定的元素,也可删除列表对象,一旦删除列表对象,该对象就不再存在
pop如果不指定索引,默认删除最后一个元素
3.5、其他方法
count 方法统计某个元素在列表中出现的次数
extend 方法连接两个列表
index 查找某个元素的第一次出现的索引
reverse 反转列表;
sort 排序
in运算符,可以进行成员运算
index查找某个元素的第一次出现的索引
reverse方法,反转列表;sort方法排序
成员运算,判断某个元素是否在列表中
4、元组
元组可以看作是不可变的列表
元组用"( )"标识。内部元素用逗号隔开,如果元祖中只有一个元素,该元素后也要跟一个逗号
元组的元素同样可以是字符、数字、字符串及元组(元组同样支持嵌套)
元组属于不可变对象的属性,因此元组是不可变的
元组的操作:
1)、分片
注意:原组元素输出时使用的是圆括号,而列表元素输出时使用的是方括号
以下是元组无效的,因为元组是不可变的,不允许更改或更新某元素的值
2)、其它操作
元组只有2个方法
count 计算某个元素在元组中出现的个数
index(self, value, start=None, stop=None) 计算某个元素在元组中的索引
start和stop指定在某个索引范围内(包含start,不包含stop)查找value元素
注意:如果在指定的范围内查找不到该元素,将会报错
示例:
test_tup = ('to','be','or','not','to','be')
print(test_tup.count(test_tup[0])) #第一个元素在元组中出现的次数
print(test_tup.index('be')) #be这个元素在元组中的第一次出现的索引
print(test_tup.index('be', 1, 3)) #包含第一个索引
print(test_tup.index('be', 2, 5)) #不包含第二个索引,将会报错
5、字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型,是python中唯一一种映射类型,采用key-value形式存储数据,字典中key必须唯一。
key必须是可hash的,可hash表示key必须不可变类型(不能原位修改),如数字,字符串,元组,
而value也可任意嵌套
列表是有序的对象集合;字典是无序的对象集合
二者相同点:都属于可变对象的属性,都能够原位改变
二者的不同点:字典中的元素是通过键key来存取的(因此不能分片),而列表通过索引存取(可分片)
字典用"{ }"标识,字典由索引(key)和它对应的值value组成。 key:value
字典相关的操作:
1)、增、改、查
values 打印字典中所有的值value,列表形式返回
keys 打印字典中所有的key列表形式返回
items 同时打印字典中所有的key和value,key和value组成元组,以列表形式返回
test_dic = {'name':'jack','age':'23'}
print(test_dic)
test_dic['hooby'] = 'footabll' #增加一个字典元素
print(test_dic)
test_dic['hooby'] = 'basketball' #修改一个字典元素
print(test_dic)
test_dic = {'name':'jack','age':'23'}
test_dic2 = {'work':'teacher','national':"China"}
test_dic.update(test_dic2)
#合并两个字典,如果test_dic2中含有和test_dic中相同的key,将会覆盖test_dic1中的key和对应的value
print(test_dic)
test_dic = {'name':'jack','age':'23'}
print(test_dic['age']) #打印出指定的key的对应的value
print(test_dic.get('age')) #根据给定key返回value
print(test_dic.get('age')) #根据给定key返回value
test_dic.setdefault('hobby','football') #查找字典中是否有hobby的key,如果没有,增加这个key,并指定value为footabll,不指定value默认为None,如果有这个key则什么也不做
print(test_dic)
test_dic.setdefault('hobby','basketbool') #字典中已经有hobby这个key,因此什么也不做
print(test_dic)
test_dic = {'name':'jack','age':'23'}
print(test_dic.keys()) #打印所有的key,返回列表
print(test_dic.values())
#打印所有的value,返回列表
print(test_dic.items()) #成对打印key和value,返回列表
2)、删除
clear 清空字典中的所有元素,字典成为空字典
pop 根据key值清除字典中的元素(必须指定key),并返回清除的key对应的value
del 即可清除字典中的某个元素,也可清除字典对象
popitem 随机清除一个字典元素
test_dic3 = {'work':'teacher','national':"China",'name':'jack'}
print(test_dic3.pop('national')) #清除这个national这个元素,并返回这个key对应的value
print(test_dic3)
print(test_dic3.popitem()) #随机清除一个元素,并以元组形式返回(‘k’, ’v’)
print(test_dic3)
# del test_dic3['name'] #清除name这个元素
# print(test_dic3)
# del test_dic3 #删除test_dic3这个字典对象,后面不能再操作这个对象,否则报错
#print(test_dic3)
#将会报错
3)、创建字典并为所有key赋予同一个初始值
注意:修改后的效果,每个字典元素的第二个元素都被修改
4)、排序,字典的排序默认是按照key进行排序的
注意:字典没有专用于排序的方法,只能使用内建的sorted函数进行排序
sorted(dic) #默认按升序进行排序
sorted(dic, reverse=True) #按降序排序
5)、字典的遍历
test_dic = {'name':'jack','age':'23','color':'red','national':'China'}
for i in test_dic: #默认是根据key进行循环,并打印
print(i)
print()
for i in test_dic.keys(): #明确指定根据key循环,并打印
print(i)
print()
for i in test_dic.values(): #明确指定根据value循环,并打印
print(i)
print()
for i,v in test_dic.items():
#明确指定是根据key和value进行循环,并打印
print(i, ':',v)
小结:
序列:字符串、列表、元组
非序列:数值、字典
可变对象:列表、字典
不可变对象:数值、字符串、元组
6、文件
文件操作模式:
模式 |
描述 |
r |
以只读方式打开文件。文件的指针放在文件的开头,默认模式。 |
rb |
以二进制格式打开一个文件用于只读。文件指针放在文件的开头。默认模式。 |
r+ |
打开一个文件用于读写,文件指针放在文件的开头。 |
rb+ |
以二进制格式打开一个文件用于读写。文件指针放在文件的开头。 |
小结:只要是与r相关的模式操作,打开文件后,文件指针总是放在文件的开头处 |
|
w |
打开一个文件只用于写入。如果该文件已存在,则清除文件中的内容。如果该文件不存在,创建新文件。 |
wb |
以二进制格式打开一个文件只用于写入。如果该文件已存在,则清除文件中的内容。如果该文件不存在,创建新文件。 |
w+ |
打开一个文件用于读写。如果该文件已存在,则清除文件中的内容。如果该文件不存在,创建新文件。 |
wb+ |
以二进制格式打开一个文件用于读写。如果该文件已存在,则清除文件中的内容。如果该文件不存在,创建新文件。 |
小结:只要是与w相关的操作,若文件事先存在,打开文件后总会先清空文件的内容,若文件不存在则创建文件 |
|
a |
打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。 也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
ab |
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。 也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
a+ |
打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。 文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。 |
ab+ |
以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。 如果该文件不存在,创建新文件用于读写。 |
小结:只要是与a相关的操作,如果文件事先存在,打开文件后不会清空文件,并将文件的指针放在文件的最后; 若文件不存在将会创建文件,因为是新建的空文件,指针在开头处 |
对数据文件的操作是Python的内置模块,只要使用open函数,根据文件的打开模式,获取到文件的句柄,就可以对文件进行读、写、追加操作。语法形式如下:
方式一:fp = open('文件名', '文件打开模式')
方式二:with open('文件名') as fp:
如果打开了文件之后就不再处理该文件了,那么使用with语句可以使程序编写得更为简洁,离开with之后,系统自动会关闭文件,就不需要使用fp.close()去手动关闭文件
testfile2测试文件内容:
fp:打开文件的句柄,对文件的操作就是对文件句柄的操作,有以下操作方法:
fp.read([size]) size字符串的索引值,不包括自身size,即打印索引值为0-(seze-1)个字符
fp.readline([size]) 同上,seize是字符串索引值,不包括自身
示例:
fp = open('testfile2','r',encoding='utf-8')
print(fp.readline(6)) #打印后文件指针将移动到第六个字符后
fp.seek(0)
#将文件指针移动到文件开头
print(fp.readline())
fp.readlines([size]) 把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。size同样为字符串索引值,不包括自身;只要size位于某一行字符的索引范围内,该行就会被打印出来
示例:
fp = open('testfile2','r',encoding='utf-8')
print(fp.readlines())
fp.seek(0)
print(fp.readlines(7))
fp.seek(0)
print(fp.readlines(8))
fp.write(str) 把str写到文件中并返回写入的字符个数,write()并不会在str后自动加上一个换行符
示例:
fp = open('testfile2','w',encoding='utf-8')
print(fp.write("hello world!")) #原文件将会被清空,然后写入这里的字符串
fp.writelines(seq) 把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入,不会在每行后面加上任何东西。
示例:
fp = open('testfile2','w',encoding='utf-8')
msg = '''
test for test
how are you
am fine
'''
print(fp.writelines(msg)) #将多行原样写入,返回None
fp.close() 关闭文件,使用open函数打开一个文件后不会自动关闭,因此如果使用open函数,书写时一定要同时写出close函数,然后再在二者之间书写文件操作语句。如果一个文件在关闭后还对其进行操作会产生ValueError
fp.flush() 有时向文件中写入字符串时,会暂时将内容存储在内存的缓冲区中,并不会立即写到磁盘文件上,使用该指令将会把缓冲区的内容写入硬盘
fp.fileno() 返回一个整型的文件描述符(file descriptor FD整型),可用于底层操作系统的 I/O 操作
fp.isatty() 文件是否是一个终端设备文件(unix系统中一切皆文件,终端设备也是文件)
fp.tell() 返回光标的当前位置(按字节计算),以文件的开头为原点
fp = open('testfile2','r',encoding='utf-8')
fp.seek(0)
print(fp.readline(2))
print(fp.tell())
fp.next() 返回下一行,并将光标移动到下一行,python 3.x中该函数更改为__next__
把一个file用于for … in file这样的语句时,就是调用next()函数来实现遍历的。
fp.seek(offset[,whence]) 将光标移到offset位置(和tell类似,也是按照字节计算)。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了。
whence可以取值为:
0表示从头开始计算(默认)。
1表示以当前位置为原点计算。
2表示以文件末尾为原点进行计算。
注意:如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。
fp.truncate([size]) 使用该函数,文件必须可写,返回当前光标所在索引位置。size是截取的文件大小,按字节截取,(无论光标再何处)总是从文件的开头开始截取。
如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去
with语句:
with open('testfile1','r+',encoding='utf-8')
as fp1, open('testfile2','r+') as fp2: #同时操作多个文件使用逗号间隔
print(fp1.readlines())
print(fp2.readlines())
#操作完成后,不需要手动关闭文件,会自动关闭
7、集合
把不能的元素组合在一起,无序,成员不可重复
组成集合的成员唯一不能重复
集合中的成员是一组无序排列的可哈希的值(即唯一):因此集合的成员可作为字典的key
集合的创建:
st = 'china'
li = [1, 2, 'a', 'b', 'c']
tu = (1, 2, 'a','b','c')
se1 = set(st)
#set()函数可用于将序列转换为集合,若序列中有重复,将会去重
se2 = set(li)
se3 = set(tu)
print(se1, se2, se3)
# dic = {se1:1, se2:2, se3:3}
#会报错,可变集合本身不能作为字典的key
# print(dic)
集合分类:可变集合、不可变集合
可变集合:可以添加和删除元素,不可hash,不能用作字典的key,也不能作为其它集合的元素,
注意:这里的可变指的是集合本身,而不是指集合中的成员,因此可变集合本身不能作为字典的key,因为其是不可hash的
不可变集合(frozenset):与上述相反
不可变集合的创建:
str2 = 'test for test'
li2 = ['a', 'b', 'c', 1, 2]
tu2 = ('a', 'b', 'c', 1, 2)
fse1 = frozenset(str2) #创建不可变集合
fse2 = frozenset(li2)
fse3 = frozenset(tu2)
print(fse1)
print(fse2)
print(fse3)
dic2 = {fse1:1, fse2:2, fse3:3} #不可变集合本身可作为字典的key
print(dic2)
1)、访问集合:
集合本身是无序的,不能通过索引取值,又没有字典的key,因此也不能通过类似字典的方式取值。
只能通过循环遍历或使用in、not in来访问或判断几何元素
li = [1, 2, 'a', 'b', 'c', 'c']
se1 = set(li)
print('a' in se1)
print('b' not in se1)
for i in se1:
print(i, end=' ')
2)、更新集合(针对可变集合)
li = ['t', 'n', 'a', 'b', 'c', 'c']
s = set(li)
print(s)
s.add('uuuID') #uuuID作为一个整体添加到集合s中
print(s)
s.update('uuuID') #将uuuID当作一个序列添加到集合s中,因此会将u、I、D添加到集合中
print(s)
s.update(['o','i','p', 'a',
'b']) #update的参数必须是一个可迭代的序列,可以是列表、字符串、元组
print(s)
s.remove('uuuID') #删除集合中的uuuID元素
print(s)
s2 = s.pop() #pop随机删除一个集合元素,并返回被删除的元素
print(s,
s2)
s.clear() #清空集合
print(s)
del s #删除集合
#print(s) #将会报错
s.discard(x) 如果在set “s”中存在元素x, 则删除
集合相关的操作:
1、in、not in 成员运算
2、集合等价与不等价(==,!=)
3、子集、超集
4、并集、交集、差集、对称差集(反向差集)
s = set('to be or not to be')
s1 = set('be')
print('t' in s) #成员关系
print(s1 < s) #子集运算
print(s1.issubset(s) ) #子集运算
print(s > s1) #超集运算
print(s.issuperset(s1)) #超集运算
s1 = set('china')
s2 = set('test nova')
print(s1 | s2) #并集运算
print(s1.union(s2)) #并集运算
print(s1.isdisjoint(s2)) #判断两个集合是否不相交,如果2个集合交集为空,返回True
print(s1 & s2) #交集运算
print(s1.intersection(s2)) #交集运算
print(s1 - s2) #差集,s1中有,s2中没有
print(s1.difference(s2)) #差集,s1中有,s2中没有
print(s1 ^ s2) #对称差集,s1、s2不重复的元素,s1&s2的补集
print(s1.symmetric_difference(s2)) #对称差集,s1、s2不重复的元素,s1&s2的补集
print(s1,s2)
#
s1.difference_update(s2) #s1对s2进行差集操作的结果更新s1,返回值为None
#
print(s1)
#
s1.symmetric_difference_update(s2) #s1对s2进行反向差集操作的结果更新s1,返回值为None
#
print(s1)
s1.intersection_update(s2) #s1对s2进行交集操作的结果更新s1,返回值为None
print(s1)
深浅copy
知识补充:
a = 2
b = a #a和b分别指向了同一块内存空间,
a = 1 #因此,修改a的值不会影响b的值
print(a,b) #结果是:1 2
a = [1, 3, 4]
b = a #b同样和a指向了同一块内存空间,但是这里指向的是整个列表的内存空间,如果修改
#a的值,b的也会跟着变,因为b仅指向整个列表的空间,并没有指向内部元素的内存空间
#此时,a和b共享同一块内存,b可看作是a的别名,
#这种情况同样适用于其它复杂数据类型,不仅仅是列表
a[1] = 'test'
#修改a[1]的值
print(a,b) #结果相同,都被修改
浅copy与上述类似
在Python中对象的赋值其实就是对象的引用。当创建一个对象,把它赋值给另一个变量的时候,python并没有拷贝这个对象,只是拷贝了这个对象的引用而已。
浅拷贝:拷贝了最外围的对象本身(即第一层),内部的元素都只是拷贝了一个引用而已。也就是,把对象复制一遍,但是该对象中引用的其他对象我不复制
深拷贝:外围和内部元素都进行了拷贝对象本身,而不是引用。也就是,把对象复制一遍,并且该对象中引用的其他对象我也复制
必要说明:
变量:是一个系统表的元素,拥有指向对象的连接空间
对象:被分配的一块内存,存储其所代表的值
引用:是自动形成的从变量到对象的指针
注意:类型(int类型,long类型(python3已去除long类型,只剩下int类型的数据))属于对象,不是变量
不可变对象:一旦创建就不可修改的对象,包括字符串、元组、数字,不能够原位修改
可变对象:可以修改的对象,包括列表、字典,可以原位修改
切片可以应用于:列表、元组、字符串,但不能应用于字典(因为切片是跟索引进行的,字典没有索引)。
深浅拷贝:既可应用序列(列表、元组、字符串),也可应用字典。
不可变类型,不管是深拷贝还是浅拷贝,地址值和拷贝后的值都是一样的
可变对象深浅拷贝:
=拷贝:值相等,地址相等,整个对象
copy浅拷贝:值相等,地址不相等,整个对象及对象内的第一层
deepcopy深拷贝:值相等,地址不相等,整个对象及对象内的所有层
深copy:
深拷贝需要调用copy模块中的deepcopy函数,另外,copy模块中含有个copy函数(实际就是浅copy)