一、Python入门

目录

　　一、编程与编程语言

　　二、编程语言分类

　　三、python介绍

　　四、安装python解释器

　　五、变量

　　六、用户与程序交互

　　七、基本数据类型

　　八、数据类型总结

　　九、运算符

　　十、多元赋值(多变量赋值)

 

一  编程与编程语言

　　python是一门编程语言，作为学习python的开始，需要事先搞明白：1.编程的目的是什么？2.什么是编程语言？3.什么是编程?

　　编程的目的：

#计算机的发明，是为了用机器取代/解放人力，而编程的目的则是将人类的思想流程按照某种能够被计算机识别的
表达方式传递给计算机，从而达到让计算机能够像人脑/电脑一样的自动执行的效果。

　　什么是编程语言？

#上面提及的能够被计算机所识别的表达方式即编程语言，语言是沟通的介质，而编程语言是程序员与计算机沟通的介
质。在编程的世界里，计算机更像是人的奴隶，人类编程的目的就是命令奴隶去工作

　　什么是编程？

#编程即程序员根据需求把自己的思想流程按照某种编程语言的语法风格编写下来，产出的结果就是包含一堆字符的文件

#强调：程序在未运行前，跟普通文件无异，只有程序在运行时，文件内所写的字符才有特定的语法意义

 

二 编程语言分类

　　编程语言的发展经历了

#机器语言：站在计算机（奴隶）的角度，说计算机能听懂的语言，那就是直接用二进制编程，直接操作硬件

#汇编语言：站站计算机（奴隶）的角度，简写的英文标识符取代二进制去编写程序，本质仍然是直接操作硬件

#高级语言：站在人（奴隶主）的角度，说人话，即用人类的字符去编写程序，屏蔽了硬件操作

　　高级语言更贴近人类语言，因而造成了：它必须被翻译成计算机能读懂二进制后，才能被执行，按照翻译方式分为

#编译型（需要编译器，相当于用谷歌翻译）：如c语言，执行速度快，调试麻烦

#解释型（需要解释器，相当于同声传译）：如python，执行速度慢，调试方便

　　

 

三 python介绍

　　介绍

　　python的创始人为吉多.范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，Guido开始写能够解释Python语言语法的解释器。Python这个名字，来自Guido所挚爱的电视剧Monty Python's Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可扩展的语言。

　　最新的TIOBE排行榜，Python赶超PHP占据第4，Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言

　　目前Python主要应用领域

#1.WEB开发----最火的Python web框架Django，支持异步高并发的Tornado框架，短小精悍的flask，bottle，Django官方的标语把Django定义为the framework for perfectionist with deadlines（大意是一个为完全主义者开发的高效率web框架）
#2.网络编程----支持高并发的Twisted网络框架，py3引入的asyncio使异步编程变的非常简单
#3.爬虫----爬虫领域，Python几乎是霸主地位，Scrapy\Requests\BeautifulSoup\urllib等，想爬啥就爬啥
#4.云计算----目前最火最知名的云计算框架就是OpenStack，Python现在的火，很大一部分就是因为云计算
#5.人工智能----谁会成为AI和大数据时代的第一开发语言？这本已是一个不需要争论的问题。如果说三年前，Matlab、Scala、R、Java、和Python还各有机会，局面尚且不清楚，那么三年之后，趋势已经非常明确了，特别是前不久Facebook开源了PyTorch之后，Python作为AI时代头牌语言的位置基本确立，未来的悬念仅仅是谁能坐稳第二把交椅。
#6.自动化运维----问问中国的每个运维人员，运维人员必须会的语言是什么？10个人相信会给你一个相同的答案，它的名字叫Python
#7.金融分析----很多分析程序，高频交易软件就是用Python,目前，Python是金融分析，量化交易领域里用的最多的语言
#8.科学计算----97年开始，NASA就在大量使用Python在进行各种复杂的科学运算，随着NumPy,SciPy,Matplotlib,Enthought librarys等众多程序库的开发，使得python越来越适合于科学计算、绘制高质量的2D和3D图像。和科学计算领域最流行的商业软件Matlab相比，Python是一门通用的程序设计语言，比Matlab所采用的脚本语言的应用范围更广泛
#9.游戏开发----在网络游戏开发中Python也有很多应用。相比Lua or C++,Python比Lua有更高阶的抽象能力，可以用更少的代码描述游戏业务逻辑，与Lua相比，Python更适合作为一种Host语言，即程序的入口点是在Python那一端会比较，然后用C/C++在非常必要的时候写一些扩展。Python非常适合编写1万行以上的项目，而且能够很好地把网游项目的规模控制在10万行代码以内。知名的游戏《文明》就是用Python写的

　　Python在一些公司的应用

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

　　Python（解释器）的发展史

#1989年，Guido开始写Python语言的编译器
#1991年，第一个Python编辑器诞生。它是用C语言实现的，并能够调用C语言的库文件。从一出生，Python已经具有了：类、函数、异常处理、包含表和词典在内的核心数据类型，以及模块为基础的扩展系统。
#Granddaddy of Python web frameworks, Zope 1 was released in 1999
# Python 1.0 -- January 1994增加了lambda,map,filter and reduce.
# Python 2.0 -- October 16,2000，加入了内存回收机制，构成了现在Python语言框架的基础
# Python 2.4 -- November 30, 2004，目前最流行的WEB框架Django诞生
# Python 2.5 -- September 19, 2006
# Python 2.6 -- October 1, 2008
# Python 2.7 -- July 3, 2010
# In November 2014,it was announced that Python 2.7 would be supported until 2020, and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
#Python 3.0 -- December 3, 2008（这里解释清楚，为什么08年就出3.0,2010年反而又推出2.7？是因为3.0不向下兼容2.0，导致大家都拒绝升级3.0，无奈官方只能推出2.7过渡版本）
#Python 3.1 -- June 27,2009
# Python 3.2 -- February 20 ,2011
# Python 3.3 -- September 20, 2012
# Python 3.4 -- March 16,2014
# Python 3.5 -- September 13 , 2015
# Python 3.6 -- 2016-12-23 发布python3.6.0版本

　　Python的发展前景如何？

#知乎上一篇文章，问Python未来10年的发展前景
#http://www.zhihu.com/question/22112542/answer/166053516

　　Python有哪些种类？

我们知道Python是一门解释型语言，代码想运行，必须通过解释器执行，Python的解释器本身也可以看做是程序，这个程序是什么语言开发的呢？答案是好多种语言？因为Python有好几种解释器，分别基于不同语言开发的，每个解释器特点不同，但都能正常运行Python代码，分别来看：

#CPython:CPython是使用最广泛且官方的Python解释器，本教程以CPython为准
当我们从Python官方网站下载并安装好Pyhton3后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器用C语言开发，所以叫CPython,在命令行下运行python就是启动Cpython解释器

#IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比如很多国产浏览器虽然外观不同，但内核其实都是调用IE。
CPython用>>>作为提示符，而IPythony用In [序列]:作为提示符

#PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Pyhton代码的执行速度。
绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在俩种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点

#Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行

#IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码解释成.Net的字节码

 　　Python 2 or Python 3区别？

#待更新

 

四 安装python解释器

　　Python目前已支持所有主流操作系统，在Linux，Unix，Mac系统上自带Python环境，在Windows系统上安装如下：

 

#测试安装是否成功
windows系统---->运行---->输入cmd,然后回车，弹出cmd程序，输入python,如果能进入交互环境，代表安装成功

#查看Pyhton安装版本
windows系统---->运行---->输入cmd,然后回车，弹出cmd程序，输入python -V

#多版本共存演示
此处针对Windows系统进行讲解，分别安装Python2.7 和Python3.6，存放在不同目录，将各自目录下的python.exe，分别复制一份并更名为Python2.exe或Python3.exe，（此处为啥不删除python.exe，因为pip工具胡调用它）。

#如何将Python2和Python3加入环境变量
计算机----属性----高级系统设置----高级----环境变量-----系统变量----Path----编辑----将Python2和Python3的根目录分别加入即可

五、变量

　　什么是变量？

#变量即变化的量

　　为什么要有变量？

#程序执行的本质就是一系列状态的变化，变是程序执行的直观体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态以及状态的变化。
#比如：
    英雄的等级为1，打怪升级变为10
    僵尸的存活状态为True，被植物打死了，于是变为False
    人的名字为lisl，也可以修改为Lisl

　　如何定义变量？

#变量名（相当于门牌号，指向值所在的空间），等号，变量值
name = 'Lisl'
sex = 'male'
age =18

　　变量的定义规范

#1. 变量名只能是 字母、数字或下划线的任意组合
#2. 变量名的第一个字符不能是数字
#3. 关键字不能是变量名 如：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

　　变量命名推荐方式

#驼峰体
AgeOfMary = 56
NumberOfStudents = 80

#下划线（推荐使用）
age_of_mary = 56
number_of_students = 80

　　定义变量名不好的方式

#1. 变量名为中文、拼音
#2. 变量名过长
#3. 变量名词不达意

　　定义变量会有：id , type , valu#1. 等号比较的是value#2. is比较的是id

#强调：
#1. id相同，意味着type和value必定相同
#2. value相同，type肯定相同，但id可能不同，如下：
>>>x='Your age is : 18'
>>>y='Your age is : 18'
>>>id（x）
35707400
>>>id(y)
35707544
>>>
>>> x==y
True
>>> x is y
False

问题：
　　x='Your '
　　y='Your '
　　a='Your'
　　b='Your'
>>> x is y
False
>>> a is b
True
以上例子，为什么字符串有没有空格，会影响到结果是否占用同一内存地址？
因为python有驻留机制：

  1.整数驻留
    小整数对象池：python在执行的时候，为了节约空间，帮我们创建好了小整数对象池，[-5~256]，都是固定的地址，不管你用不用，都会存在。
    比如，a=5,b=5,id(a)和id(b)的地址都是小整数池中固定已经存在的地址，所以相等

  2.字符串的驻留
    仅包含字母、数字、下划线的字符串，python会启用驻留机制，a='123k_b' b='123k_b' id(a)和id(b)地址是一样的

　　变量的修改赋值问题

#注意变量是门牌号，指向的是存放数据的内存地址，而非数据
>>>n1='hello'
>>>n2 =n1
>>> n1 is n2
True
>>>id(n1)
35722216
>>>id(n2)
35722216

#更改n1的值
>>>n1='HELLO'
>>>n1
'HELLO'
>>>n2
'hello'
>>> n1 is n2
False
>>>id(n1)
35722104
>>>id(n2)
35722216

　　常量

常量即不变的量，如pai=3.141592653...或在程序运行过程中不会改变的量，一般用大写表示，如AGE=20

六、用户与程序交互

　　Python2 与Python3区别之一：

#在Python3中
input：用户输入任何值，都存成字符串类型

#在Python2中
input：用户输入什么类型，就存成什么类型
raw_input：等于Python3的input

　　注释类型：

#单行注释用#，多行注释用三对双引号""" xxxx"""

　　注释原则：

#1. 不用全部加注释，只需要在自己觉得重要或不好理解的部分注释即可
#2. 注释可以用中文或英文，但不能用拼音

　　文件头

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

七、基本数据类型

　　数字

#int 整型
定义：age = 10    #age=int(10)


#float浮点型
定义：height=1.78    #height=float(1.78)

#int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31~2**31-1
在64位机器上，整数的位数为64位，取值范围为-2**63~2**61-1

#long（长整型）           python3没有长整型，统一叫整型    
跟C语言不通，Python的长整型没有指定位宽，即：Python没有限制长整型数值的大小，但实际上由于机器内存有限，我们使用的长整型数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换成长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了
>>>a = 2**64
>>>type(a)
<type 'long'>
>>>b= 2 **60
>>>type(b)
<type 'int'>

#complex复数型
>>> x=1-2j
>>>x.imag    #虚数位
-2.0
>>>x.real    #实数位
1.0

　　字符串

#在Python中，加了引号的字符就是字符串类型，python并没有字符类型
定义：name='lisl'    #name=str('lisl')

#单引号、双引号、多引号有什么区别？
    单引号和双引号没有区别，只有字符串包含单引号或双引号时，才需要采用相反的引号进行区别，如：
msg= "My name is Lisl,I'm 18 year old!"

#多引号用于多行字符串，如：
msg='''
床前明月光，
疑似地上霜。
举头望明月，
低头思故乡。
'''
print (msg)

#数字可以进行加减乘除运算，字符串只能进行相加或相乘
>>>name='lisl'
>>> age='18'
>>>name + age    #加号为简单拼接
'lisl18'
>>>name*5        #乘号为字符串倍数复制
'lisllisl'lisl'lisl'lisl''

#注意1：字符串相加的效率不高
字符串1+字符串3，并不会在字符串1基础上加字符串3，而是申请一个全新的内存空间存入字符串1和字符串3，相当于字符串1与字符串3的空间被复制了一次

#注意2：只能字符串加字符串，不能字符串加其他类型

　　

　　列表

#在[]内用逗号分割，可以存放n个任意类型的值
定义：students1=['lisl','zhangsan','lisi'] #students2=list(['lisl','zhangsan','lisi'])

>>>students1 is students2
False
>>>students1 == students2
True
>>>students1[0] is students2[0]
True
#列表为将所有的门牌号同一放在一个叫列表的地方，列表内的元素是引向某个数据的门牌号（内存地址），因此students1[0] is students2[0]返回True

#存放多个学生的信息：姓名，年龄，爱好
>>>student_info=[['lisl',18,['python','play']],['wangdong',18,['speak','girls']]]    #列表嵌套
>>>students_info[0][2][0]    #列表取值

>>>list_1=['hello', 'world', ['lisl', '18']]
>>>list_3=['hello', 'world', ['lisl', '18'],['hello', 'world', ['lisl', '18']]]
>>>list_4=[66, 15, 30, 22, 88, 1]

>>>list_1.append(element)    #增加元素进列表末位，element为要增加的元素名

>>>list_1.clear()    #清空列表内所有元素，留下空列表[]，而del list_1是删除整个列表

>>>list_2=list_1.copy()    #创建一个新的列表，元素的值复制到新列表，为浅复制，嵌套列表复制过去的是地址的引用，如下例子：
>>>list_1 is list_2
False
>>>list_1 == list_2
True
>>>list_1[0]='HELLO'
>>>list_1
['HELLO', 'world', ['lisl', '18']]
>>>list_2        #一层元素不会随着原列表改变而改变
['hello', 'world', ['lisl', '18']]
>>>list_1[2][2]='20'
>>>list_1
['HELLO', 'world', ['lisl', '20']]
>>>list_2
['hello', 'world', ['lisl', '20']]

list_1.count(element)    #统计element在列表里出现的次数，注：只能统计一层，不能统计嵌套列表内元素

>>>list_1.extend(iterable)    #将可迭代对象拼接在list_1尾部
>>>list_1.extend(list_2)    #列表拼接列表，元素一一传入
['hello', ['lisl', '18'], 'hello', 'world', ['lisl', '18']]
>>>dic_1={'lisl':{'123':3}}
>>>list_1.extend(dic_1)    #只将字典key拼接在list_1里
['hello', 'world', ['lisl', '18'], 'lisl']
>>>list_1.extend("name is Li")#将字符串每个元素拼接在list_1,包括空格
['hello', 'world', ['lisl', '18'], 'n', 'a', 'm', 'e', ' ', 'i', 's', ' ', 'L','i']

>>>L.index(value,[start,[stop]])    #从start开始，stop结束范围查找，返回value所在索引（索引号以列表index为准，跟start,stop位置无关）
>>>list_3('world',3,5)    #从索引[3:5)查找'world'，返回索引号
4

>>>L.insert(index,object)    #在索引index插入对象
>>>list_1.insert(0,'Hurry')

>>>L.pop([index])-->item    #要删除索引index的元素，默认是最后一个
>>>list_1.pop()    #删除最后一个元素
>>>list_1.pop(2)    #删除索引2的元素

>>>L.remove(value)-->None    #删除列表元素value,无返回值
>>>list_1.remove('hello')

>>>L.reverse()    -->None    #反向排序
>>>list_1.reverse()
>>>list_1
[['lisl', '18'], 'world', 'hello']

>>>L.sort(key=None,reverse=False)-->None #排序，默认从小到大
>>>list_4.sort()    #从小到大排序
[1, 15, 22, 30, 66, 88]
>>>list_4.sort(reverse=True)    #从大到小排序
[88, 66, 30, 22, 15, 1]

 

　　字典

#为什么要用字典？
存放一个人的信息:姓名，性别，年龄，很明显是多个值，既然是存多个值，我们完全可以基于刚刚学习的列表存放，如下
>>>info = ['egon','male',18]
定义列表的目的不单单是为了存，还要考虑取值，如果我想取出这个人的年龄，可以用
>>>info[2]
18
但这是基于我们已经知道在第3个位置存放的是年龄的前提下，我们才知道索引2对应的是年龄即:
#name,sex,age
info=['egon','male',18]
而这完全只是一种假设，并没有真正意义上规定第三个位置存放的年龄，于是我们需要寻求一种，即可以存放多个任意类型的值，又可以硬性规定值的映射关系的类型，比如key=value，这就用到了字典

#在{}内用逗号分隔，可以存放多个key:value的值，value可以是任意类型
定义:info={'name':'egon','age':18,'sex':'male'}
#info=dict({'name':'egon','age':18,'sex':'male'})
用于标识:存储多个值的情况，每个值都有唯一一个对应的key，可以更为方便高效地取值

info={
    'name':'lisl',
    'hobbies':['play','sleep'],
    'company_info':{
          'name':'nfyg',
          'type':'wifi',
          'emp_num':40,
    }
}
print (info['company_info']['name'])    #取公司名

info={'name':'lisl','age':18,'sex':'male'}
#info['name']    #取值
#info['age']=20   #改值
#len(info)    #长度
# ‘name’ in info   #返回True
#'text' not in info   #返回True
#del info['sex']    #删除某个元素
# info.pop('sex')  #删除某个元素
#info.popitem()   #随机删除某个元素
#info.clear()      #清空字典所有元素
#info.keys()      #返回字典所有的key，返回值为类，需要用for取每个元素
#info.values()    #返回字典所有的value,返回值为类，需要用for取每个元素
#info.items()      #返回key，value，,返回值为类，需要用for取每个元素
#for k,v in info.items():print (k,v)  #循环取值
#for k in info:print (k)      #循环取key值

 

'''
setdefault的功能:
1.key存在，则不赋值，key不存在则设置默认值
2.key存在，返回的是key对应的已有的值，key不存在，返回的是设置的默认值
d={}
print (d.setdefault('a',1))    #返回1

d={'a':2222}
print (d.setdefault('a',1))     #返回2222

'''
例子:统计字符
s='hello lisl lisl say hello sb sb'
d={}
words=s.split()
for word in words:
    d.setdefault(word,s.count(word))
    print (d)

 

　　元组

age=(11,22,33,44,55)   本质age=tuple((11,22,33,44,55))
age[2:4]       #正向切片
age[-1:2:-1]   #反向取
age[2]     #按索引取值，不能赋值
len(age)   #计算长度
'a' not in age    #返回True
for i in age:    
     print (i)    #循环取值

 

　　集合

作用：去重，关系运算

定义：
    集合：可以包含多个元素，用逗号分隔
    集合的元素遵循三个原则：
        1.每个元素必须是不可变类型（可hash，可作为字典的key），例如列表不能成为集合元素
        2.没有重复的元素
        3.无序

s={'a','b','c'}    #可定义为s=set({'a','b','c'})
len(s)    #计算集合长度
'd' not in s    #返回True


s1={'a','b','c'}
s2={'b','c','d'}
#关系型运算
s1 | s2    #合集，并集，结果为{'a','b','c','d'}
s1.union(s2)   #合集

s1 & s2    #交集，结果为{'b','c'}
s1.intersection(s2)   #交集

s1 - s2     #差集，结果为{'a'}
s1.difference(s2)   #差集


s1 ^ s2    #对称差集，结果为{'a','d'}
s1.symmetric_difference(s2)

#强调：集合之间做比较，指的是包含与被包含
s3={'a','b'}
s4={'a','b','c'}
s3 < s4    #s3子集，s4父集,结果True
s3.issubset(s4)　　#s3是s4子集，结果是True
s4.issuperset(s3)  #s4是s3父集，结果是True

#需要掌握的操作
s1={'a','b','c'}
s2={'b','d','f'}
s1.difference_update(s2)    #s1=s1-s2 或者s1=s1.difference(s2)
s1.intersection_update(s2)    #s1=s1 & s2或者s1=s1.intersection(s2)
s1.symmetric_difference_update(s2)   #s1=s1 ^ s2  对称差集结果赋值给s1
s1.update(s2)    #s1=s1 | s2


#可证明集合无序
s1={'a','b','c'}
print(id(s1))
s1.add('d')    #集合添加元素'd'
print(s1,id(s1))


s1={'a','b','c'}
res=s1.remove('b') # 只是单纯的删除，没有返回值
print(s1)
print(res)
s1.remove('dddd') # 元素 不存在则报错

res=s1.discard('b') #只是单纯的删除，没有返回值
print(s1)    #结果{'c', 'a'}
print(res)    #结果None
s1.discard('dddd')# 元素不存在也不报错


res=s1.pop() #随机删除，有返回值
print(res)    #结果c

 

#只需要了解的知识点
s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2))   #s1与s2没有公共交集部分则返回True


用集合去重，局限性很强：
# 1、不能保证原数据类型的顺序
# 2、原数据类型中包含的元素必须全都为不可变类型

　练一练：

　　将列表去重后，顺序不变

#方法一：
l=[
    {'name':'egon','age':18,'sex':'male'}, #'egon' 18 male
    {'name':'alex','age':73,'sex':'male'}, #
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
s=set() #  本子
new_l=[]
for d in l:
    values=(d['name'],d['age'],d['sex'])
    print(values)
    if values not in s:
        s.add(values)
        new_l.append(d)

print(new_l)


方法二：
l=[
    {'name':'egon','age':18,'sex':'male'}, #'egon' 18 male
    {'name':'alex','age':73,'sex':'male'}, #
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
s=[] #  本子

for d in l:
    if d not in s:
        s.append(d) #[]

print(s)

 

 

 

八、数据类型总结

按存储空间的占用（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
字典：无序，需要存key与value映射的相关信息，字典可变，需要处理数据的增删改查，字典里的key是不可变
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

按存值个数区分

一个值	数字，字符串
多个值	列表，元组，字典

 

按可变不可变区分

可变	列表、字典	值变，id不变，不可hash
不可变	数字，字符串、元组	值变，id变，可hash

 

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问(映射类型)	字典

 

九、运算符

#身份运算(is  ,  is not)
is比较的是id，==比较的是值
若id相同，值一定相同，而值相同，id未必相同，可用id和值来判断是否是可变或者不可变数据

>>>x=123
>>>y=123
>>>x == y
True
>>>id(x)
3581040
>>>id(y)
31550448

>>>x is y
False

 

十、多元赋值(多变量赋值)

　　基本要点

#1.任何可迭代对象都可以直接解析成多个变量
#2.a,b,c只是元组(a,b,c)的缩写，可直接在解释器里验证
#定长解析时变量个数与可迭代对象所含元素个数要对应，不然会报异常
#不定长解析使用*,允许变量个数小于元素个数

　　_忽略值

#解析迭代对象时，不一定需要所有的值，此时可以用_忽略相应位置的值，其实_只是个变量名而已，用其他标志名也一样，只是这个符号看起来更直白一点
#eg:
a,_ = (1,2)    #a=1,_=2

　　*不定长解析

#注：Python2中不支持
#1.最多只能用一个*符号列表解析
#2.变量个数最多比可迭代对象所含元素个数多一个，此时*解析出来的是空列表
#例如：
a,*b = (1,2,3,4,5)  #a=1,b=[2,3,4,5]

a,*b,c = (1,2,3,4,5)    #a=1,b=[2,3,4,],c=5

a,*b = (1,)    #a=1,b=[]
a,*_=(1,)        #a=1,_=[]

a,b,c,*d = (1,2)     #报错，变量个数比可迭代对象元素多2个，不符合第2点