原文地址：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431658624177ea4f8fcb06bc4d0e8aab2fd7aa65dd95000

一 初识Python

python是一种面向对象、解释型的计算机程序语言。Python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中Python作为程序的名字，是因为他是BBC电视剧——蒙提·派森的飞行马戏团（Monty Python's Flying Circus）的爱好者。ABC是由吉多参加设计的一种教学语言。就吉多本人看来，ABC这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，吉多认为是非开放造成的。吉多决心在Python中避免这一错误，并获取了非常好的效果，完美结合了C和其他一些语言。

Python的设计哲学是“优雅”、“明确”、“简单”。Python开发者的哲学是“用一种方法，最好是只有一种方法来做一件事”，也因此它和拥有明显个人风格的其他语言很不一样。在设计Python语言时，如果面临多种选择，Python开发者一般会拒绝花俏的语法，而选择明确没有或者很少有歧义的语法。

目前Python主要应用领域：

云计算: 云计算最火的语言， 典型应用OpenStack
    WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django
    科学运算：典型库NumPy, SciPy, Matplotlib

系统运维: 运维人员必备语言
    金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤其擅长策略回测
    图形GUI: PyQT, WxPython,TkInter

人工智能: Enthought librarys,pandas，谷歌Tensorflow

二 Python入门知识

1.Hello World！

1 print("hello world!)

打印一个语句"hello world！" So easy！！！

2.编码

python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill）

ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号，显然ASCII码无法将世界上的各种文字和符号全部表示，所以，就需要新出一种可以代表所有字符和符号的编码，即：Unicode

Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，
注：此处说的的是最少2个字节，可能更多

UTF-8，是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存

python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill），所以如果不指定编码类型，如果有中文就会报错。

3.注释

#单行注释

"""多行注释

     多行注释"""

'''多行注释

     多行注释'''

4.变量

声明变量

1 name = "999"

2 name = ‘name 2’

3 age = 18

4 city = "Chengdu"

什么是变量？请回忆初中数学所学的代数基础知识：

设正方形的边长为a，则正方形的面积为a x a。把边长a看做一个变量，我们就可以根据a的值计算正方形的面积，比如：

若a=2，则面积为a x a = 2 x 2 = 4；

若a=3.5，则面积为a x a = 3.5 x 3.5 = 12.25。

在计算机程序中，变量不仅可以为整数或浮点数，还可以是字符串，因此，name作为一个变量就是一个字符串。

变量声明的规则

变量声明有规则，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，某些关键字不能使用

例如：['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']

尽量使用有含义的变量名！

5.用户输入与输出

1 #Python3.x

2 name = input("请输入你的姓名“）  #使用input()接收用户收入的内容并打印

3 print(name)

4

5 #Python2.x

6 name = raw_input("请输入你的姓名“）

7 print name 

6.模块初识

模块即库，Python的强大之处在于他有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持。

使用 import xxx   实现

import getpass  #输入密码时，如果想要不可见，需要利用getpass 模块中的 getpass方法

password = getpass.getpass("请输入密码：")

print(password)

7.PYC是什么？

执行Python代码时，如果导入了其他的 .py 文件，那么，执行过程中会自动生成一个与其同名的 .pyc 文件，该文件就是Python解释器编译之后产生的字节码。

ps：代码经过编译可以产生字节码；字节码通过反编译也可以得到代码。

8.数据类型

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，

不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：

1.数字

int（整型）
　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型）
　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
float（浮点型）
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
complex（复数）

2.布尔型  Boolean

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True

True

>>> False

False

>>> 3 > 2

True

>>> 3 > 5

False

布尔值可以用and、or和not运算。

and运算是与运算，只有所有都为True，and运算结果才是True：

>>> True and True

True

>>> True and False

False

>>> False and False

False

>>> 5 > 3 and 3 > 1

True

or运算是或运算，只要其中有一个为True，or运算结果就是True：

>>> True or True

True

>>> True or False

True

>>> False or False

False

>>> 5 > 3 or 1 > 3

True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> not True

False

>>> not False

True

>>> not 1 > 2

True

布尔值经常用在条件判断中，比如：

if age >= 18:

    print('adult')

else:

    print('teenager')

3.字符串  String

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

• 转义

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：

'I\'m \"OK\"!'

表示的字符串内容是：

I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

>>> print('I\'m ok.')

I'm ok.

>>> print('I\'m learning\nPython.')

I'm learning

Python.

>>> print('\\\n\\')

\

\

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义：

>>> print('\\\t\\')

\       \

>>> print(r'\\\t\\')

\\\t\\

str = "helloworld"

 str.capitalize()   #首字母大写，输出结果Helloworld

 str.casefold()     #大写全部转小写

 str.center(15,"*")   #输出    ***helloworld**

 str.count('l')            #统计字符串种出现的次数，输出结果为3

 str.encode()            #将字符串编码成bytes格式

 str.endswith("ld")   #判断结尾是否以“ld”结尾，输出结果为True   同理有startwith()方法

 str.index('e')        #返回e所在字符串的索引

 str.isalnum()       #是否为字母数字

 str.isdigit()           #判断是否整数

 str.isnumeric()        #是否为数字

 str.isprintable()       #是否可打印

 str.isspace()           #是否为空格

 str.istitle()               #是否为标题

 str.isupper()            #是否全为大写

 str.isalpha()             #是否是字母，带数字之类的为False

 str.islower()              #是否全为小写

 str.isdecimal()          #是否包含十进制数字

 str.isidentifier()        #检测一段字符串可否被当作标志符，即是否符合变量命名规则

 str.swapcase()            #大小写互换

#jion（）方法，以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

str = "-";

seq = ("a", "b", "c")     # 字符串序列

print(str.join( seq ))

输出：a-b-c

#split() 方法，以string为分隔符，分割字符串

str = "Helloworld"

m = str.split("o")   #split("o",2)可设置最大分割次数

print(m)

#输出 ['Hell', 'w', 'rld']

str.strip()   #去掉字符串左右两边的空格，lsrtip()即只去除左边的空格

str.find("o")   #检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-14 str.rfind("o")   #类似于 find()函数，但是从右边开始查找.

#partition   把字符串分割成一个3元素 元组

str = "Helloworld"

m = str.partition("o")

print(m)
#输出 ('Hell', 'o', 'world')


 #ljust()，填充字符串，同理还有rjust()方法

 str = "Helloworld"

 m = str.ljust(15,"*")

 print(m)

# 输出 Helloworld*****


 #replace()方法，新字符串替代旧字符串

 str = "Helloworld"

 m = str.replace("Hello","Nihao")

 print(m)

#输出 Nihaoworld

• 格式化

我们经常会输出类似'亲爱的xxx你好！你xx月的话费是xx，余额是xx'之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。

在Python中，采用的格式化方式和C语言是一致的，用    % 实现，举例如下：

>>> 'Hello, %s' % 'world'

'Hello, world'

>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)

'Hi, Michael, you have $1000000.'

字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：

>>> 'growth rate: %d %%' % 7

'growth rate: 7 %'

常用-----> 字符串 %s;整数 %d;浮点数%f

另一种实现方法之format()方法

1 print('Hi,{name},{message}'.format(name = 'Duke',message = 'i am in Chengdu'))

4.列表  List

list是一种有序的集合，可以随时添加和删除其中的元素。

比如，列出班里所有同学的名字，就可以用一个list表示：

>>> classmates = ['Michael', 'Bob', 'Tracy']

>>> classmates

['Michael', 'Bob', 'Tracy']

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

>>> classmates[0]

'Michael'

>>> classmates[1]

'Bob'

>>> classmates[2]

'Tracy'

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

>>> classmates[-1]

'Tracy'

>>> classmates[-2]

'Bob'

>>> classmates[-3]

'Michael'

list是一个可变的有序表，所以，可以往list中追加元素到末尾：

>>> classmates.append('Adam')

>>> classmates

['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引号为1的位置：

>>> classmates.insert(1, 'Jack')

>>> classmates

['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用del()/remove()/pop()方法方法：

>>> classmates.pop()

'Adam'

>>> classmates

['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmates.pop(1)

'Jack'

>>> classmates

['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> classmates[1] = 'Sarah'

>>> classmates

['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同，比如：

>>> L = ['Apple', 123, True]

list元素也可以是另一个list，比如：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']

>>> len(s)

4

要注意s只有4个元素，其中s[2]又是一个list，如果拆开写就更容易理解了：

>>> p = ['asp', 'php']

>>> s = ['python', 'java', p, 'scheme']

要拿到'php'可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。

如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

>>> L = []

>>> len(L)

0

使用extend()方法,连接两个list:

1 names = ["Ronaldo","Messi","Torres","Gerrard","Suarez"]

2 names2 = ["Bale","Higuaín"]

3

4 names.extend(names2)

5 print(names)

['Ronaldo', 'Messi', 'Torres', 'Gerrard', 'Suarez', 'Bale', 'Higuaín']

count统计元素个数:

1 names = ["Ronaldo","Messi","Torres","Gerrard","Suarez","Messi"]

2

3 count = names.count("Messi")

4 print(count)

5 #输出结果：2

index获取元素下标

1 names = ["Ronaldo","Messi","Torres","Gerrard","Suarez","Messi"]

2

3 index = names.index("Messi")

4 print(index)

#输出结果：1       只返回第一个找到的下标

使用reverse()方法翻转列表:

1 names = ["Ronaldo","Messi","Torres","Gerrard","Suarez"]

2

3 names.reverse()

4 print(names)

['Suarez', 'Gerrard', 'Torres', 'Messi', 'Ronaldo']

使用sort()方法排序:

1 names = ["Ronaldo","Messi","Torres","Gerrard","Suarez"]

2

3 names.sort()

4 print(names)

['Gerrard', 'Messi', 'Ronaldo', 'Suarez', 'Torres'] #按照字母顺序

注意：Python3里不同数据类型不能放在一起排序
这样的列表使用sort方法排序会报错 names = ["Ronaldo","Messi","Torres","Gerrard","Suarez",1,2]

复制list:

copy.copy  称为浅copy....   所谓浅copy就是对引用的拷贝

copy.deepcopy 称为深copy...  所谓深copy就是完成拷贝一个副本

 1 import  copy

 2 a=['hello',[1,2,3]]

 3 b=copy.copy(a)

 4 c=copy.copy(a)

 5

 6 a[0]='world'

 7 a[1].append(4)

 8 print(a)

 9 print(b)

10 print(c)

    ['world', [1, 2, 3, 4]]

    ['hello', [1, 2, 3, 4]]

    ['hello', [1, 2, 3]]

通过输出结果发现，浅copy的列表b，由于a列表进行中的第二个元素列表进行了修改，b列表随着a改变。c列表完全是最初a列表的副本，不受a变化的影响。

5.元组  Turple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法，又叫只读列表。元组只有Count和Index方法。

其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

1 count = names.count("Ronaldo")

2 index = names.index("Ronaldo")

3 print(count,index)

1 0

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t = (1, 2)

>>> t

(1, 2)

如果要定义一个空的tuple，可以写成()：

>>> t = ()

>>> t

()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>> t = (1)

>>> t

1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1,)

>>> t

(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

最后来看一个“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])

>>> t[2][0] = 'X'

>>> t[2][1] = 'Y'

>>> t

('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

别急，我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

6.字典  Dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

names = ['Michael', 'Bob', 'Tracy']

scores = [95, 75, 85]

给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

>>> d['Michael']

95

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。

你可以猜到，这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

>>> d['Adam'] = 67

>>> d['Adam']

67

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d['Jack'] = 90

>>> d['Jack']

90

>>> d['Jack'] = 88

>>> d['Jack']

88

如果key不存在，dict就会报错：

>>> d['Thomas']

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 'Thomas'

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

>>> 'Thomas' in d

False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')

>>> d.get('Thomas', -1)

-1

注意：返回None的时候Python的交互环境不显示结果。

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d.pop('Bob')

75

>>> d

{'Michael': 95, 'Tracy': 85}

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

#update 把一个字典的键值添加到另外一个字典里

d = {"name1":"Michael ",

     "name2":"Trevor",

     "name3":"Franklin "}

d2 = {"name4":"Niko"}

d.update(d2)

print(d)

{'name1': 'Michael ', 'name2': 'Trevor', 'name4': 'Niko', 'name3': 'Franklin '}

#setdefault  查找键值， 键不存在时，设置默认键值

d = {"name1":"Michael ",

     "name2":"Trevor",

     "name3":"Franklin "}

m = d.setdefault("name1","Niko")

t = d.setdefault("name4","Niko")

print(m)

print(t)

#输出Michael

#输出Niko

# 函数以列表返回可遍历的(键, 值) 元组数组

d = {"name1":"Michael ",

     "name2":"Trevor",

     "name3":"Franklin "}

u = d.items()

print(u)

dict_items([('name2', 'Trevor'), ('name3', 'Franklin '), ('name1', 'Michael ')])

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

>>> key = [1, 2, 3]

>>> d[key] = 'a list'

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list'

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])

>>> s

{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

重复元素在set中自动被过滤：

>>> s = set([1, 1, 2, 2, 3, 3])

>>> s

{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)

>>> s

{1, 2, 3, 4}

>>> s.add(4)

>>> s

{1, 2, 3, 4}

通过update([a,b])方法可以增加多项元素：

#增加多项

set1.update([5,10])

#输出{1, 2, 5, 6, 8, 9, 10}

通过remove(key)方法可以删除元素：

>>> s.remove(4)

>>> s

{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

set1 = set([1,2,6,8,9])

set2 = set([3,6,9])

a = set1 | set2   #求并集

a = set1.union(set2)

print(a)

{1, 2, 3, 6, 8, 9}

a = set1 & set2    #求交集

a = set1.intersection(set2)

print(a)

{9, 6}

a = set1 - set2  #求差集

a = set1.difference(set2)

print(a)

{8, 1, 2}

a = set1 ^ set2   #求对称差集，即获得两个集合不交叉的元素

a = set1.symmetric_difference(set2)

{1, 2, 3, 8}

################

set1 = set([1,2,6,8,9])

set2 = set([6,9])

a = set1 >= set2   #集合1是否包含集合2    等价于issuperset()方法

b = set1 <= set2   #集合2是否包含集合1    等价于 issubset()方法

print(a)

print(b)

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

str是不变对象，而list是可变对象。

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']

>>> a.sort()

>>> a

['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

>>> a = 'abc'

>>> a.replace('a', 'A')

'Abc'

>>> a

'abc'

虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'，应该怎么理解呢？

我们先把代码改成下面这样：

>>> a = 'abc'

>>> b = a.replace('a', 'A')

>>> b

'Abc'

>>> a

'abc'

要始终牢记的是，a是变量，而'abc'才是字符串对象！有些时候，我们经常说，对象a的内容是'abc'，但其实是指，a本身是一个变量，它指向的对象的内容才是'abc'：

┌───┐                  ┌───────┐

│ a │─────────────────>│ 'abc' │

└───┘                  └───────┘

当我们调用a.replace('a', 'A')时，实际上调用方法replace是作用在字符串对象'abc'上的，而这个方法虽然名字叫replace，但却没有改变字符串'abc'的内容。相反，replace方法创建了一个新字符串'Abc'并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串'abc'，但变量b却指向新字符串'Abc'了：

┌───┐                  ┌───────┐

│ a │─────────────────>│ 'abc' │

└───┘                  └───────┘

┌───┐                  ┌───────┐

│ b │─────────────────>│ 'Abc' │

└───┘                  └───────┘

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

7.空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。

8.常量

所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.14159265359

事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法。

9.数据运算

算数运算:

比较操作符:

赋值运算符：

位运算符：

逻辑运算符：

10.流程控制

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

比如，输入用户年龄，根据年龄打印不同的内容，在Python程序中，用if语句实现：

age = 20

if age >= 18:

    print('your age is', age)

    print('adult')

1.if 表达式

if else：

age = 3

if age >= 18:

    print('your age is', age)

    print('adult')

else:

    print('your age is', age)

    print('teenager')

if elif else：

age = 3

if age >= 18:

    print('adult')

elif age >= 6:

    print('teenager')

else:

    print('kid')

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else.

2.循环

while循环：当条件为真的时候运行，当条件为假的时候停止

在循环中，break语句可以提前退出循环.

1 count = 0

2 while True:

3     print("conut:",count)

4     count += 1

5     if count == 10000:

6         break    #当count等于10000时候退出

ps:break表示停止循环，而coutinue语法是跳出整个循环进入下次循环

n = 0

while n < 10:

    n = n + 1

    if n % 2 == 0: # 如果n是偶数，执行continue语句

        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行

    print(n)

for循环：

for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。

再比如我们想计算1-10的整数之和，可以用一个sum变量做累加：

sum = 0

for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:

    sum = sum + x

print(sum)

1 for i in range(10):

2     print("loop:", i )

输出结果为：0，1，2，3，4，5，6，7，8，9，10

另外一个例子：

1 for i in range(0,10,2):    #2为步长，不写其实默认为0

2     print("loop:",i)

输出结果为：0，2，4，6，8

Type()方法

获取变量的类型

name = "Duke"

print(type(name))

#输出结果  <class 'str'>

num = 998

print(type(num))

#输出结果  <class 'int'>

最新文章

1. RxAndroid+Retrofit+MVVM（1）OKHttp
2. wampserver 403 禁止访问
3. DOM查找元素
4. Building Workspace速度慢的原因
5. jdk、jre与jvm的区别与联系
6. Weex的环境搭建以及集成到Android项目
7. 【算法】RMQ LCA 讲课杂记
8. canvas星空和图形变换
9. DBCP连接池TestOnBorrow的坑
10. Python迭代和解析(2)：迭代初探
11. 机器学习入门之python实现图片简单分类
12. 从Scratch到Python:会动的小猫
13. Android Studio移除模块
14. 前端lvs访问多台nginx代理服务时出现404错误的处理
15. openERP笔记 自定义模块开发
16. hdu 5441 Travel (2015长春网赛)
17. Azure Resource Manager 概述
18. JavaScript原型链基础(prototype chain)
19. .net修炼笔记
20. EM算法小结

热门文章

1. Rsync同步部署web服务端配置
2. Appium移动自动化测试-----（五） java-client安装与测试
3. 学习笔记：oracle学习三：SQL语言基础之sql语言简介、用户模式
4. QT qml TreeView展示数据结构于界面
5. 用pytorch1.0搭建简单的神经网络：进行多分类分析
6. java多线程中篇（二） —— 线程的创建和Synchronized锁关键字
7. Java基础---Java 数组
8. WUSTOJ 1336: Lucky Boy（Java）博弈
9. javascript之new操作符
10. hdu 2102 a计划问题。。 双层dfs问题