python基础--python基本知识、七大数据类型等

在此申明一下,博客参照了https://www.cnblogs.com/jin-xin/，自己做了部分的改动

（1）python应用领域

目前Python主要应用领域：

  • 云计算: 云计算最火的语言， 典型应用OpenStack，k8s
  • WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django，flask，Tornado
  • 科学运算、人工智能: 典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas
  • 系统运维: 运维人员必备语言
  • 金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤其擅长策略回测
  • 图形GUI: PyQT, WxPython,TkInter

Python在一些公司的应用：

  • 谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发
  • CIA: 美国中情局网站就是用Python开发的
  • NASA: 美国航天局(NASA)大量使用Python进行数据分析和运算
  • YouTube:世界上最大的视频网站YouTube就是用Python开发的
  • Dropbox:美国最大的在线云存储网站，全部用Python实现，每天网站处理10亿个文件的上传和下载
  • Instagram:美国最大的图片分享社交网站，每天超过3千万张照片被分享，全部用python开发
  • Facebook:大量的基础库均通过Python实现的
  • Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的
  • 豆瓣: 公司几乎所有的业务均是通过Python开发的
  • 知乎: 国内最大的问答社区，通过Python开发(国外Quora)
  • 春雨医生：国内知名的在线医疗网站是用Python开发的
  • 除上面之外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝 、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务。

（2）python的发展史

python发展史

（3）python的优点

  • Python已经占据前三的位置， Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。

  • Python整体呈上升趋势，Python应用越来越广泛并且也逐渐得到业内的认可！！！

  • Python可以应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。目前业内几乎所有大中型互联网企业都在使用Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。

  • 先看优点

    1. Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。
    2. 开发效率非常高，Python有非常强大的第三方库，基本上你想通过计算机实现任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上再进行开发，大大降低开发周期，避免重复造轮子。
    3. 高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节
    4. 可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工 作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就几乎可以在市场上所有的系统平台上运行
    5. 可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
    6. 可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

  • 再看缺点

    1. 速度慢，Python 的运行速度相比C语言确实慢很多，跟JAVA相比也要慢一些，因此这也是很多所谓的大牛不屑于使用Python的主要原因，但其实这里所指的运行速度慢在大多数情况下用户是无法直接感知到的，必须借助测试工具才能体现出来，比如你用C运一个程序花了0.01s,用Python是0.1s,这样C语言直接比Python快了10倍,算是非常夸张了，但是你是无法直接通过肉眼感知的，因为一个正常人所能感知的时间最小单位是0.15-0.4s左右，哈哈。其实在大多数情况下Python已经完全可以满足你对程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种情况下，当然还是建议你用C去实现的。
    2. 代码不能加密，因为PYTHON是解释性语言，它的源码都是以名文形式存放的，不过我不认为这算是一个缺点，如果你的项目要求源代码必须是加密的，那你一开始就不应该用Python来去实现。
    3. 线程不能利用多CPU问题，这是Python被人诟病最多的一个缺点，GIL即全局解释器锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使得任何时刻仅有一个线程在执行，Python的线程是操作系统的原生线程。在Linux上为pthread，在Windows上为Win thread，完全由操作系统调度线程的执行。一个python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。关于这个问题的折衷解决方法，我们在以后线程和进程章节里再进行详细探讨。

  • 当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。

  • 由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码（当然难度很大）。事实上，确实存在多种Python解释器。

（4）python的注释、变量、常量

python的注释

  • 注释的意义：在实际开发的过程中，有些时候我们开发的代码可能忘记了实现什么功能或者怎么开发的，那么注释就可以帮助我们快速的回忆和理解我们当时所写代码的真正含义。同时，当我们在公司接手一个他人留下来的项目，我们要快速的了解这个项目的情况，注释是可以帮助我们了解熟悉这个项目的代码情况。总之，注释是十分重要的，一个好的程序员必须养成写注释的习惯。

  • 一行注释：# 被注释内容 快捷键:Ctrl+/

  • 多行注释：'''被注释内容'''，或者"""被注释内容"""

python变量的命名规则

  • 变量名只能是 字母、数字或下划线的任意组合

  • 变量名的第一个字符不能是数字

  • 以下关键字不能声明为变量名（python的关键字不可以命名）
    ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

  • 变量的定义要具有可描述性。

  • 驼峰体

    IsDefault = 66
NumberOfStudents = 88
StudentName = 'AndreasZhou'

  • 下划线

    age_of_oldboy = 66
number_of_students = 88
student_name = 'AndreasZhou'

  • 定义变量不好的方式举例

    变量名为中文、拼音

    变量名过长

    变量名词不达意

python变量的使用方法

  • python变量的使用方法是直接赋值，python会根据用户的赋值的具体值，来分配相应的内存地址，分配内存空间。

  • python变量与c、java、javascript等语言是不一样的，变量使用的时候不用说明变量具体的数据类型，这是python的其中一个优势，比较适合初学者去学习，但是在变量的时候要做到见名知意，通俗易懂的。

    例如：

    People = '孙悟空'  
Name = '秃头宝贝'
number_of_stus = 88
# 直接赋值即可，那么变量被声明使用
print(People, Name, number_of_stus)
# 输出的结果为：孙悟空 秃头宝贝 88

python常量的命令规则和使用方法

  • 常量即指不变的量，如pai 3.141592653..., 或在程序运行过程中不会改变的量

  • 在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量

    AGE_OF_OLDBOY = 66
PAI = 3.14

  • python中常量的使用方法和变量的使用方法是类似的，只是常量是不可以再次改变和赋值的量，值是不会受到改变的。

（5）python的常用数据类型

什么是数据类型？

  • 我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种， 数字、字符串、布尔类型等

    Python中常用的数据类型有多种，如下：

    　整数(int) ,浮点型(float),字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

    1. int。数字：主要用于运算。1 ，2,3...
    2. float。数字：主要用于运算。1.14, 3.14...
    3. bool。判断真假：True, False.
    4. str。简单少量的储存数据，并进行相应的操作。name = 'alex',
    5. tuple。只读，不能更改。(1,'alex')
    6. list：大量有序数据，[1,'ses',True,[1,2,3],{'name':'jinxin'}]
    7. dict：大量数据，且是关联性比较强的数据 {'name':'jinxin','age':18,'name_list':['张三'，'李四']}
    8. set:

整数类型（int）

  • int（整型）

    在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647

    在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807

  • 十进制转换成二进制

    十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。

    十进制小数转换成二进制小数采用"乘2取整，顺序排列"法。具体做法是：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。

    img

  • 二进制转化成十进制

    要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右

    例如：二进制数1101.01转化成十进制

    1101.01(2)=120+021+122+123+02-1+12-2=1+0+4+8+0+0.25=13.25(10)

    所以总结起来通用公式为：

abcd.efg(2)=d20+c21+b22+a23+e2-1+f2-2+g*2-3(10)

或者是：

把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。这种做法称为"按权相加"法。

此时，1101=8+4+0+1=13

再比如：二进制数100011转成十进制数可以看作这样：

数字中共有三个1 即第一位一个，第五位一个，第六位一个，然后对应十进制数即2的0次方+2的1次方+2的5次方， 即

100011=32+0+0+0+2+1=35

  • int操作方法

    因为数字主要是用于计算，所以针对于数字可以使用的方法除了那些运算之外，没有什么经常会用的方法，python给咱们提供了一种方法：bit_length()就是帮助你快速的计算整数在内存中占用的二进制码的长度.

    num = 10
print(num.bit_length())  # 当十进制用二进制表示时，最少使用的位数
# 运行结果: 4

浮点型（float）

  • 浮点数的介绍

    float（浮点型）是Python基本数据类型中的一种，Python的浮点数类似数学中的小数和C语言中的double类型；

  • 浮点型的运算

    浮点数和整数在计算机内部存储的方式是不同的，整数运算永远是精确的，然而浮点数的运算则可能会有四舍五入的误差。比如观察以下运算，在数学中很容易得出结果应该是0.8965，而使用程序运算得出的结果却是：0.8965000000000001；

a = 1.25
b = 0.3535
print(a-b)  #输出：0.8965000000000001
  • 整型和浮点型运算的结果也是浮点型；
a = 1
b = 0.25
print(a + b,type(a+b))  #输出：1.25 <class 'float'>
print(a - b,type(a-b))  #输出：0.75 <class 'float'>
print(a * b,type(a*b))  #输出：0.25 <class 'float'>
print(a / b,type(a/b))  #输出：4.0 <class 'float'>
  • float() 函数可以将整数和字符串转换成浮点数。
#整数转为浮点数
a = 1
print('a的类型为：',type(a))   #输出：a的类型为： <class 'int'>
print(float(a))      #输出：1.0
print('转换后a的类型为：',type(float(a)))  #输出：转换后a的类型为： <class 'float'>
#字符串转为浮点数
b = '123'
print('b的类型为：',type(b))   #输出：a的类型为： b的类型为： <class 'str'>
print(float(b))      #输出：123.0
print('转换后b的类型为：',type(float(b)))  #输出：转换后b的类型为： <class 'float'>
  • float() 函数将 符合 浮点型 的规范的字符串 转换成 float 型。
    num1 = "123.12";
    num2 = float(num1);
    print("num2: %f" % num2);
    '''
    num2: 123.120000
    '''

字符串类型（str）

  • 什么是字符串

    在Python中,加了引号(引号可以是单引号或者是双引号)的字符都被认为是字符串！简单少量的储存数据，并进行相应的操作。

    name = "Andreas Zhou" #双引号
age = "23"       #只要加引号就是字符串
age2 = 23          #int
msg = '''My name is Andreas, I am 22 years old!'''  #我擦，3个引号也可以
hometown = 'JiangXi'   #单引号也可以

    那单引号、双引号、多引号有什么区别呢？ 让我大声告诉你，单双引号木有任何区别，只有下面这种情况 你需要考虑单双的配合

    msg = "My name is Andreas , I'm 23 years old!"

    多引号什么作用呢？作用就是多行字符串必须用多引号,可以实现多行打印出来

    msg = '''
今天我想写首小诗，
歌颂我的同桌，
你看他那乌黑的短发，
好像一只炸毛鸡。
'''
print(msg)

  • 字符串拼接

    数字可以进行加减乘除等运算，字符串呢？让我大声告诉你，也能？what ?是的，但只能进行"相加"和"相乘"运算。

    >>> name
'Andreas Zhou'
>>> age
'22'
>>> 
>>> name + age  #相加其实就是简单拼接
'Andreas Zhou22'
>>> 
>>> name * 10 #相乘其实就是复制自己多少次，再拼接在一起
'Andreas ZhouAndreas ZhouAndreas ZhouAndreas ZhouAndreas ZhouAndreas ZhouAndreas ZhouAndreas ZhouAndreas ZhouAndreas Zhou'

    注意，字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接

    >>> type(name),type(age2)
(<type 'str'>, <type 'int'>)
>>> 
>>> name
'Andreas Zhou'
>>> age2
23
>>> name + age2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects #错误提示数字 和 字符 不能拼接

  • 字符串的常用方法

    1. 字符串的索引和切片

      组成字符串的字符从左至右，依次排列，他们都是有顺序的，就好比是部队的队列，从左至右依次报号(从零开始) ：0,1,2,3....

      索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

      a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])

      切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

      a = 'ABCDEFGHIJK'
print(a[0:3])  # print(a[:3]) 从开头开始取0可以默认不写
print(a[2:5])
print(a[:]) #默认到最后
print(a[:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[:5:2]) #加步长print(a[-1:-5:-2]) #反向加步长

    2. count

      # count 统计某个字符出现的次数
s8 = 'dasdbqjwkbdkjanxnkdqhdkasnfjkasfnoianla'
print(s8.count('a'))
# 输出的结果为：6

    3. upper lower

      s1 = 'python学习'
s = 'CHINess'
# upper lower
# 将字符串中的所有的英文字符转变为大写
# 不会对原字符串进行任何操作，都是产生一个新的字符串
s2 = s1.upper()
print(s2)
print(s1, type(s1))
# 将字符串中的所有的英文字符转变为小写的字符
s3 = s.lower()
print(s3)
# 输出的结果如下：
# PYTHON学习
# python学习 <class 'str'>
# chiness

    4. startswith

      s = 'CHINess'
# 表示求的是以什么为开始，以什么开始，如果是对的返回True，如果不是则返回的是False
print(s.startswith('t'))  # False
print(s.startswith('C'))  # True
# 了解,表示的是从3这个位置开始到6这个位置结束，是否为B开始
print(s.startswith('B', 3, 6)) # False

    5. replace

      # replace
msg = 'Andreas 很nb,Andreas是创始人之一，Andreas长的很帅'
# msg1 = msg.replace('Andreas', 'zhouqian') # 默认是全部替换
msg1 = msg.replace('Andreas', 'zhouqian', 2)  # 从左到右依次替换，替换的数目
print(msg)
print(msg1)
# 输出的结果如下：
# Andreas 很nb,Andreas是创始人之一，Andreas长的很帅
# zhouqian 很nb,zhouqian是创始人之一，Andreas长的很帅

    6. strip

      # strip：空白 ：空格， 	 

# strip是用于去除空白
s4 = '   
周乾	'
print(s4)
s5 = s4.strip()
print(s5)
# 输出的结果如下：
# 周乾
# 周乾

# 了解
# 可以用于去除指定的字符
s5 = 'rre周乾qsd'
s6 = s5.strip('qrsed')
print(s6)
# 输出的结果如下：
# 周乾

    7. split（重点）

      # split 非常重要 切割成列表，将字符串切割成列表
# str -----》list的转换
# 默认按照空格分隔，返回的是一个列表
s8 = '周乾 女神 男神'
ll = s8.split()
print(ll)  # ['周乾', '女神', '男神'],输出的结果，默认按照空格分隔，返回一个列表
# 指定分隔符分隔，返回的是一个列表
s8 = '周乾：女神：男神'
lll = s8.split('：')
print(lll) # ['周乾', '女神', '男神']

s8 = '：barry：Andreas：wu'
llll = s8.split('：')
print(llll) # ['', 'barry', 'Andreas', 'wu']
# 以上三种情况，输出的三种的结果，这三种结果务必记住
# ['周乾', '女神', '男神']
# ['周乾', '女神', '男神']
# ['', 'barry', 'Andreas', 'wu']
lllll = s8.split('：', 2)
print(lllll)  # ['', 'barry', 'Andreas：wu'],按照前两个分号分隔开

    8. join（重点）

      # join 非常好用
# 将列表转换为字符串  list---》str
s1 = 'Andreas'
s2 = '+'.join(s1)
print(s2, type(s2))
# 输出的结果如下：
# a+l+e+x <class 'str'>
# 前提：列表里面的元素必须都是str类型
ll = ['周乾', '女神', '男神']
s2 = '：'.join(ll)
print(s2, type(s2))
# 输出的结果如下：
# 周乾：女神：男神 <class 'str'>

    9. format（格式化输出）

      # format:格式化输出
# 第一种用法：
msg = '我叫{}今年{}性别{}'.format('周乾', '23', '男')
print(msg)
# 第二种用法
msg = '我叫{0}今年{1}性别{2}我依然叫{0}'.format('周乾', '23', '男')
print(msg)
# 第三种用法：
msg = '我叫{name}今年{age}性别{sex}'.format(name='周乾', age='23', sex='男')
print(msg)
# 输出的结果如下：
# 我叫周乾今年23性别男
# 我叫周乾今年23性别男我依然叫周乾
# 我叫周乾今年23性别男

    10. is系列 （isalnum isalpha isdecimal isdigit）

      # is系列
# name = 'taibai123'
# True
# False
# False
name = '100四'
# True
# False
# False
print(name.isalnum())  # 字符串由字母和数字组成 alpha+number
print(name.isalpha())  # 字符串只有字母组成 alpha
print(name.isdecimal())  # 字符串只有十进制组成 decimal
print(name.isdigit())  # 字符串是否为数字组成
# 输出的结果如下：
# True
# False
# False
# False
#####is系列
name='taibai123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdecimal()) #字符串只由十进制组成
# True
# False
# False

    11. capitalize

      s1 = 'zhouqian'
# capitalize 首字母大写，其余变小写
print(s1.capitalize())
# 输出的结果为：Zhouqian

    12. swapcase

      s1 = 'zhouqian'
# 大小写翻转
print(s1.swapcase())
# 输出的结果为：ZHOUQIAN

    13. title

      # 将字符串的每一个单词的首字母大写
# 只要是非字母元素开头的都算是首字母，首字母都是要变成大写。
msg = 'zhouqian say hi'
print(msg.title())  # 每一个单词的首字母都需要大写
# 输出的结果为：Zhouqian Say Hi

    14. center

      # 居中
s1 = 'zhouqian'
# 将字符在设置的间隔里面居中
print(s1.center(20))
# 并且可以设置填充物，例如*
print(s1.center(20, "*"))
#       zhouqian      
# ******zhouqian******

    15. find index

      # find index
# find是表示的是查找字符在字符串中的位置
s1 = 'barry'
print(s1.find('a'))
# 重复的地方是直接输出第一个出现的位置
print(s1.find('r'))
'''
    find:通过元素找索引，找到第一个就返回，找不到返回-1
    index:通过元素找索引，找到第一个就返回，找不到报错
    print(s1.find('a')) # 1
    print(s1.find('r')) # 2
    print(s1.find('o')) # -1
    print(s1.index('o'))  # ValueError: substring not found
'''
# 输出的结果为：
# 1
# 2

布尔值（True，False）

  • 布尔类型很简单，就两个值 ，一个True(真)，一个False(假), 主要用记逻辑判断

  • 但其实你们并不明白对么？ let me explain, 我现在有2个值 ， a=3, b=5 , 我说a>b你说成立么? 我们当然知道不成立，但问题是计算机怎么去描述这成不成立呢？或者说a< b是成立，计算机怎么描述这是成立呢？

  • 没错，答案就是，用布尔类型

    >>> a=3
>>> b=5
>>> 
>>> a > b #不成立就是False,即假
False
>>> 
>>> a < b #成立就是True, 即真
True

    布尔值就两种：True，False。就是反应条件的正确与否。

    真 1 True。

    假 0 False。

    这里补充一下int str bool 三者数据类型之间的转换。

    # int ---> bool
i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False

# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

# int ---> str
i1 = 100
print(str(i1))  # '100'

# str ---> int  # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

列表（list）

  • Why: 我们现在已经学过的数据类型有：数字，布尔值，字符串，大家都知道数字主要用于计算，bool值主要是条件判断，只有字符串可以用于数据的存储，这些数据类型够用么？对于一门语言来说，肯定是不够用的。就说字符串

    1.字符串只能存储少量的数据，对于大量的数据用字符串操作不方便也不易存储。

    2.字符串存储的数据类型太单一，只能是字符串类型。

    例如：‘1 True alex’ 像这样的字符串，我如果通过切片或者其他方法将1 True alex 取出来，他也只能是字符串，但是我想要得到数字的1，布尔值的True，必须还要转化，是不是很麻烦。

    所以python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。

  • What:这个数据类型就是list列表。

    列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用' , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

    li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

    列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

  • Where:(这个知识点用在什么地方)：

    　　你需要存储大量的数据，且需要这些数据有序的时候。

    　　制定一些特殊的数据群体：按顺序，按规则，自定制设计数据。

  • How：那么这个列表如何使用呢？咱们从这几方面去深入研究这个列表。

    # python的基本的数据类型
# 我们目前学过的基本的数据类型有int bool str
# str存储的是少量的数据，不够开发者使用，无论对字符串的索引切片等等，获取的都是字符串类型
# str字符串存取的数据单一
# list列表，用两个中括号表示的是一个列表，列表里面可以放任何数据的类型，同时可以存大量的数据
# python常用的容器型的数据类型。list列表
# java所对应的数组
# 列表是有序的，可索引，可切片，和str的用法类似，但是有略微的区别

  • 列表的创建

    创建一个列表有三种方法

    # 方式一：（常用）
l1 = [1, 2, '周乾']

# 方式二：（不常用）
l1 = list()  # 空列表
# l1 = list(iterable)  # 可迭代对象
l1 = list('123')
print(l1)  # ['1', '2', '3']

# 方式三：列表推导式
l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

  • 列表的索引和切片

    li = [100, '周乾', True, [1, 2, 3]]
# 索引、切片，list的索引和切片和str的索引和切片其实是一样的操作
print(li[0], type(li[0]))
print(li[1], type(li[1]))
print(li[-1])
print(li[:2])
print(li[1:3])
print(li[:-1])
print(li[::2])
print(li[::-1])
# 输出的结果如下：
# 100 <class 'int'>
# 周乾 <class 'str'>
# [1, 2, 3]
# [100, '周乾']
# ['周乾', True]
# [100, '周乾', True]
# [100, True]
# [[1, 2, 3], True, '周乾', 100]
# 下面是练习题
li = [1, 3, 2, "a", 4, "b", 5,"c"]
# 通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
l1 = li[:3]
print(l1)
# 通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
l2 = li[3:6]
print(l2)
# 通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
l4 = li[1:6:2]
print(l4)
# 通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
l6 = l4[::-1]
print(l6)
# 输出的结果如下：
# [1, 3, 2]
# ['a', 4, 'b']
# [3, 'a', 'b']
# ['b', 'a', 3]

  • 列表的增删改查

    1. 列表的增（append、extend、insert）

      # 1.增
li = ['周乾', '女神', '男神', '老师', '海王']
# append:追加
li.append('zhouqian')
print(li)
# 输出的结果为：['周乾', '女神', '男神', '老师', '海王', 'zhouqian']
# # 案例
# while 1:
#     name = input('请输入新员工的姓名：（Q或者是q退出程序）')
#     # if name == 'Q' or name == 'q':
#     #     break
#     # 或者用下面的方法
#     if name.upper() == 'Q':
#         break
#     else:
#         li.append(name)

# extend:可以增加一个列表等等,迭代者追加
li.extend(['zhoukun', 'xu'])
print(li)
# 输出的结果为：['周乾', '女神', '男神', '老师', '海王', 'zhouqian', 'zhoukun', 'xu']

# insert：可以在列表的任意位置插入相应的列表元素
li.insert(2, 'Andreas')
print(li)
# 输出的结果为：['周乾', '女神', 'Andreas', '男神', '老师', '海王', 'zhouqian', 'zhoukun', 'xu']

    2. 列表的删（pop、remove、del、clear）

      li = ['周乾', '女神', '男神', '老师', '海王']
# 2.删
# 按照索引位置删除 pop
li.pop(-1)  # 按照索引删除(返回的是删除的元素)
print(li.pop(-2)) # 打印的是删除的返回值
print(li)
li.pop() # 默认删除的是最后一个
print(li)
# 输出的结果如下：
# ['周乾', '女神', '男神', '老师']
# 男神
# ['周乾', '女神', '老师']
# ['周乾', '女神']

# remove 删除指定元素的值,指定元素是什么，就把指定的元素给删除掉
li.remove('女神')  # 指定元素去删除，如果有重复的，则删除的是第一个
# 默认删除的是从左数第一个
print(li)
# 输出的结果如下：['周乾', '男神', '老师', '海王']


# clear() 清空,清空的是整个列表,但是不是删除了列表，列表还在，只是被清空了
li.clear()
print(li)
# 输出的结果如下：[]

# del
'''
  按照索引删除
'''
# 按照索引删除
del li[-1]
print(li)
# 按照切片删除
del li[::2]
print(li)
# 输出的结果如下：
# ['周乾', '女神', '男神', '老师']
# ['女神', '老师']

    3. 列表的改（按照索引和切片（步长）改）

      # 3.改
li = ['周乾', '女神', '男神', '老师', '海王']
# 按照索引改
li[0] = 'zhou'
print(li)

# 按照切片去改
li[2:] = 'adadasxasxasa'
print(li)

# 按照切片（步长）
li[::2] = 'abcabcab'
print(li)
# 输出的结果如下：
# ['zhou', '女神', '男神', '老师', '海王']
# ['zhou', '女神', 'a', 'd', 'a', 'd', 'a', 's', 'x', 'a', 's', 'x', 'a', 's', 'a']
# ['a', '女神', 'b', 'd', 'c', 'd', 'a', 's', 'b', 'a', 'c', 'x', 'a', 's', 'b']

    4. 列表的查（按照索引和切片（步长）查）

      # 4.查
# 索引，切片（步长）
for i in li:
    print(i)
# 输出的结果如下：
# 周乾
# 女神
# 男神
# 老师
# 海王

    5. count（数）（方法统计某个元素在列表中出现的次数）

      a = ["q","w","q","r","t","y"]
print(a.count("q"))
# 输出的结果为：2

    6. index（方法用于从列表中找出某个值第一个匹配项的索引位置）

      a = ["q","w","r","t","y"]
print(a.index("r"))
# 输出的结果为：2

    7. sort （方法用于在原位置对列表进行排序）

      reverse （方法将列表中的元素反向存放）

      a = [2,1,3,4,5]
a.sort()# 他没有返回值，所以只能打印a
print(a)
a.reverse()#他也没有返回值，所以只能打印a
print(a)
l1 = [5, 4, 3, 7, 8, 6, 1, 9]
l1.sort()
print(l1)
# [1, 3, 4, 5, 6, 7, 8, 9]
l1.sort(reverse=True)
print(l1)
# [9, 8, 7, 6, 5, 4, 3, 1]
l1.reverse()
print(l1)
# 翻转 [1, 3, 4, 5, 6, 7, 8, 9]

    8. 列表也可以相加与整数相乘

      # 列表可以相加
l1 = [1, 2, 3]
l2 = [1, 2, 3, '周乾', '123', '女神']
print(l1 + l2)
# 输出的结果为：[1, 2, 3, 1, 2, 3, '周乾', '123', '女神']
# 列表可以与数字相乘
l1 = [1, 2, 3]
l2 = l1 * 3
print(l2)
# 输出的结果为：[1, 2, 3, 1, 2, 3, 1, 2, 3]
# 循环一个列表时，最好不要改变列表的大小，这样会影响你的最终的结果

    9. 列表练习题

      li = ["zhouqian", "Andreas", "ritian", "barry", "wenzhou"]
# 1.计算列表的长度并输出
length = len(li)
print(length)
# 输出的结果为：5

# 2.列表中追加元素"seven",并输出添加后的列表
li.append('seven')
print(li)
# 输出的结果为：['zhouqian', 'Andreas', 'ritian', 'barry', 'wenzhou', 'seven']

# 3.请在列表的第1个位置插入元素"Tony",并输出添加后的列表
li.insert(1, 'Tony')
print(li)
# 输出的结果为：['zhouqian', 'Tony', 'Andreas', 'ritian', 'barry', 'wenzhou']

# 4.请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
li[1] = 'Kelly'
print(li)
# 输出的结果为：['zhouqian', 'Kelly', 'ritian', 'barry', 'wenzhou']

# 5.请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加
l2 = [1, "a", 3, 4, "heart"]
li.extend(l2)
print(li)
# 输出的结果为：['zhouqian', 'Andreas', 'ritian', 'barry', 'wenzhou', 1, 'a', 3, 4, 'heart']

# 6.请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加
s = 'qwert'
li.extend(s)
print(li)
# 输出的结果为：['zhouqian', 'Andreas', 'ritian', 'barry', 'wenzhou', 'q', 'w', 'e', 'r', 't']

# 7.请删除列表中的元素"ritian",并输出添加后的列表
li.remove('ritian')
print(li)
# 输出的结果为：['zhouqian', 'Andreas', 'barry', 'wenzhou']

# 8.请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
print(li.pop(2))
print(li)
# 输出的结果如下：
# ritian
# ['zhouqian', 'Andreas', 'barry', 'wenzhou']

# 9.请删除列表中的第2至4个元素，并输出删除元素后的列表
del li[1:4]
print(li)
# 输出的结果为：['zhouqian', 'wenzhou']

    10. 列表的嵌套

      l1 = [1, 2, 'zhouqian', [1, 'Andreas', 3,]]
# 1. 将l1中的'zhouqian'变成大写并放回原处。
s = l1[2].upper()
l1[2] = s
print(l1)
# 输出的结果为：[1, 2, 'ZHOUQIAN', [1, 'Andreas', 3]]

# 2.给小列表[1,'Andreas',3,]追加一个元素,'学习很重要'。
l1[3].append('学习很重要')
print(l1)
# 输出的结果为：[1, 2, 'zhouqian', [1, 'Andreas', 3, '学习很重要']]

# 3.将列表中的'zhouqian'通过字符串拼接的方式在列表中变成'zhouqiansb'
s = l1[2] + 'ab'
l1[2] = s
print(l1)
# 输出的结果为：[1, 2, 'zhouqianab', [1, 'Andreas', 3]]

元组（tuple）

  • Why:对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元组。

  • what:这个容器型数据类型就是元组。

  • 元组:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改。

  • Where:

    1.就是将一些非常重要的不可让人改动的数据放在元组中，只供查看。

    2.常用于元组的拆包。

    # 应用：
# 重要数据：用户名，密码，个人信息，不想让别人改动的数据可以存放在元组中
# 元组的拆包。分别赋值
a, b = (1, 2)  # 多一个少一个都不行，必须一对一分配好
print(a, b)

  • 元组的索引切片

    tu1 = ('a', 'b', '周乾', 3, 666)
print(tu1[0])  # 'a'
print(tu1[-1])  # 666
print(tu1[1:3])  # ('b', '周乾')
print(tu1[:-1])  # ('a', 'b', '周乾', 3)
print(tu1[::2])  # ('a', '周乾', 666)
print(tu1[::-1])  # (666, 3, '周乾', 'b', 'a')
tu = ('周乾', '女神', '男神', '小鱼', '海王', [1, 2, 3])
print(tu[0])
print(tu[:3])
for i in tu:
    print(i)
# # 获取元组的元素个数
print(len(tu))
#
tu[-1].append(666)
print(tu)
# 输出的结果如下：
# 周乾
# ('周乾', '女神', '男神')
# 周乾
# 女神
# 男神
# 小鱼
# 海王
# [1, 2, 3]
# 6
# ('周乾', '女神', '男神', '小鱼', '海王', [1, 2, 3, 666])

  • index

    index：通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错。

    tu = ('周乾', [1, 2, 3, ], 'Andreas', '女神')
print(tu.index('周乾')) # 0

  • count

    count: 获取某元素在列表中出现的次数

    tu = ('周乾', '周乾', 'WuSir', '吴超')
print(tu.count('周乾')) # 2

  • len

    len:获取的是元组的长度

    tu1 = (1,2,3,4,84,5,2,8,2,11,88,2)
print(len(tu1))
结果:
12　

字典（dict）

  • Why:咱们目前已经学习到的容器型数据类型只有list，那么list够用？他有什么缺点呢？

    1. 列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
    2. 列表只能按照顺序存储，数据与数据之间关联性不强。

    所以针对于上的缺点，说咱们需要引入另一种容器型的数据类型，解决上面的问题，这就需要dict字典。

  • what：数据类型可以按照多种角度进行分类，就跟咱们人一样，人按照地域可以划分分为亚洲人，欧洲人，美洲人等，但是按照肤色又可以分为白种人，黄种人，黑种人，等等，数据类型可以按照不同的角度进行分类，先给大家按照可变与不可变的数据类型的分类：

    不可变（可哈希）的数据类型：int，str，bool，tuple。

    可变（不可哈希）的数据类型：list，dict，set。

    字典是Python语言中的映射类型，他是以{}括起来，里面的内容是以键值对的形式储存的：

    Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。

    Value:任意数据(int，str，bool，tuple，list，dict，set)，包括后面要学的实例对象等。

    在Python3.5版本（包括此版本）之前，字典是无序的。

    在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

    当然，字典也有缺点：他的缺点就是内存消耗巨大。但是字典的查询速度是十分快的。

  • 创建字典

    # 创建字典的几种方式：
# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式5: 后面会讲到先了解
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)

# 方式6: 字典推导式
dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
print(dic)

# 方式7:利用fromkey
dic = dict.fromkeys('abcd','zhouqian')
print(dic)  # {'a': 'zhouqian', 'b': 'zhouqian', 'c': 'zhouqian', 'd': 'zhouqian'}

dic = dict.fromkeys([1, 2, 3],'zhouqian')
print(dic) # {1: 'zhouqian', 2: 'zhouqian', 3: 'zhouqian'}

  • 验证字典的合法性

    # 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key

  • 字典的增删改查

    1. 字典的增

      # 通过键值对直接增加
dic = {'name': 'zhouqian', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': 'zhouqian', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}

# setdefault
dic = {'name': 'zhouqian', 'age': 18}
dic.setdefault('height',175) # 没有height此键，则添加
print(dic) # {'name': 'zhouqian', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此键则不变
print(dic) # {'name': 'zhouqian', 'age': 18, 'height': 175}
#它有返回值
dic = {'name': 'zhouqian', 'age': 18}
ret = dic.setdefault('name')
print(ret)  # zhouqian

    2. 字典的删

      # pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': 'zhouqian', 'age': 18}
ret = dic.pop('name')
print(ret,dic) # zhouqian {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': 'zhouqian', 'age': 18}

#clear 清空字典
dic = {'name': 'zhouqian', 'age': 18}
dic.clear()
print(dic) # {}

# del
# 通过键删除键值对
dic = {'name': 'zhouqian', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#删除整个字典
del dic

    3. 字典的改

      # 通过键值对直接改
dic = {'name': 'zhouqian', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}

# update
dic = {'name': 'zhouqian', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': 'zhouqian', 'age': 18, 'sex': '男', 'height': 175}

dic = {'name': 'zhouqian', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': 'zhouqian', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}

dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}

    4. 字典的查

      # 通过键查询
# 直接dic[key](没有此键会报错)
dic = {'name': 'zhouqian', 'age': 18}
print(dic['name']) # zhouqian

# get
dic = {'name': 'zhouqian', 'age': 18}
v = dic.get('name')
print(v) # 'zhouqian'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键 

keys()
dic = {'name': 'zhouqian', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age']) 

values()
dic = {'name': 'zhouqian', 'age': 18}
print(dic.values()) # dict_values(['zhouqian', 18])

items()
dic = {'name': 'zhouqian', 'age': 18}
print(dic.items()) # dict_items([('name', 'zhouqian'), ('age', 18)])

  • 字典的其他操作

    key_list = dic.keys()    
print(key_list)
# 结果:
# dict_keys(['剑圣', '哈啥给', '大宝剑'])
# 一个高仿列表,存放的都是字典中的key

# 并且这个高仿的列表可以转化成列表
print(list(key_list))

# 它还可以循环打印
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic:
    print(i)

value_list = dic.values()
print(value_list)

# 结果:
# dict_values(['易', '剑豪', '盖伦'])
#一个高仿列表,存放都是字典中的value
# 并且这个高仿的列表可以转化成列表
print(list(value_list))

# 它还可以循环打印
for i in dic.values():   
    print(i)

key_value_list = dic.items()
print(key_value_list)
# 结果:
# dict_items([('剑圣', '易'), ('哈啥给', '剑豪'), ('大宝剑', '盖伦')])

# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值　　

# 并且这个高仿的列表可以转化成列表
print(list(key_value_list ))

# 它还可以循环打印
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic.items():
    print(i)
# 结果：
# ('剑圣', '易')
# ('哈啥给', '剑豪')
# ('大宝剑', '盖伦')

a,b = 1,2
print(a,b)
# 结果:
# 1 2

a,b = ('你好','世界')  # 这个用专业名词就叫做元组的拆包
print(a,b)
# 结果:
# 你好 世界

a,b = ['你好','大飞哥']
print(a,b)
# 结果:
# 你好 大飞哥

a,b = {'汪峰':'北京北京','王菲':'天后'}
print(a,b)
# 结果:
# 汪峰 王菲

for k,v in dic.items():
    print('这是键',k)
    print('这是值',v)

# 结果:
# 这是键 剑圣
# 这是值 易
# 这是键 哈啥给
# 这是值 剑豪
# 这是键 大宝剑
# 这是值 盖伦

  • 字典的嵌套

    字典的嵌套是非常重要的知识点，这个必须要建立在熟练使用字典的增删改查的基础上，而且字典的嵌套才是咱们在工作中经常会遇到的字典，工作中遇到的字典不是简简单单一层，而就像是葱头一样，一层接一层，但一般都是很有规律的嵌套，那么接下来我们就学习一下字典的嵌套：

    现在有如下字典，完成一下需求：

    dic = {
    'name':'汪峰',
    'age':48,
    'wife':[{'name':'国际章','age':38}],
    'children':{'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}

# 1. 获取汪峰的名字。

# 2.获取这个字典：{'name':'国际章','age':38}。

# 3. 获取汪峰妻子的名字。

# 4. 获取汪峰的第三个孩子名字。

    解题思路：

    1.获取汪峰的名字。: 这个比较简单，汪峰就是dic的一个键对应的值，我们通过这个key就可以获取到汪峰这个值。

    name = dic['name']
print(name)
    1. 获取这个字典{'name':'国际章','age':38}: 想要获取这个字典，先要看字典从属于谁？这个字典从属于一个列表，而这个列表是字典wife对应的键，所以咱们应该先通过wife获取到对应的这个列表，然后通过这个列表按照所以取值取到对应的这个字典。
    l1 = dic['wife']  # 先获取到这个列表
di = l1[0]  # 列表按照索引取值，这个字典是列表的第一个元素，所以通过索引获取到这个字典
print(di)

# 当然上面是分布获取的，我们还可以合并去写：
di = dic['wife'][0]
print(di)
    1. 获取汪峰的妻子名字: 还是按照上一题的思路：想要获取汪峰妻子的名字：国际章，那么他是一个字典的键对应的值，所以我们通过'name'这个键就可以获取到对应的值，这个题的难点是获取到这个小字典，而上一个题我们已经获取了这个小字典，所以在上面的基础上再执行就可以了。
    di = dic['wife'][0]  # 这个是上一次题获取的小字典的代码
wife_name= di['name']  # 通过小字典然后再通过键就能获取到对应的值
print(wife_name)

# 当然咱们可以简化：
wife_name = dic['wife'][0]['name]
print(wife_name)
    1. 获取汪峰的第三个孩子名字: 汪峰的孩子们是在一个字典中的，你要想获取汪峰的第三个孩子，你应该先获取到它从属于的这个字典，然后再通过这个字典获取第三个孩子的名字。
    dic2 = dic['children']  # 先获取这个字典
name = dic2['girl_three']  # 在通过这个字典获取第三个孩子的名字
print(name)

# 当然你可以简化：
name = dic['children']['girl_three']
print(name)

集合（set）

  • 集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
    1. 去重，把一个列表变成集合，就自动去重了。
    2. 关系测试，测试两组数据之前的交集、差集、并集等关系。

1.集合的创建。

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2)  # {1, 2, 'barry'} {1, 2, 'barry'}

2.集合的增。

set1 = {'Andreas','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)

#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)

3.集合的删。

set1 = {'Andreas','wusir','ritian','egon','barry'}

set1.remove('Andreas')  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

4.集合的其他操作：

　　4.1 交集。（& 或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　4.2 并集。（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

　　4.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

　4.4反交集。 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　4.5子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

5.frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

(6)其他（for，enumerate，range）

for循环：用户按照顺序循环可迭代对象的内容。

msg = 'python是全国范围内最好的编程语言，哈哈，别打我'
for item in msg:
    print(item)

li = ['Andreas','银角','女神','egon','周乾']
for i in li:
    print(i)

dic = {'name':'周乾','age':18,'sex':'man'}
for k,v in dic.items():
    print(k,v)

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['Andreas','银角','女神','egon','周乾']
for i in enumerate(li):
    print(i)
for index,name in enumerate(li,1):
    print(index,name)
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)　　　　

range：指定范围，生成指定数字。

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/stu-zhouqian/p/13131839.html