python 学习笔记

注释

以#开头的语句是注释

缩进

以四个空格替代tab缩进( 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行 )

标识符

由字母、数字、下划线(_)组成，不能以数字开头，区分大小写

清屏

import os
i = os.system("cls")  #直接使用os.system("cls")语句，清屏后会有一个0出现在屏幕上，0是os.system("cls")的返回值

获取用户输入内容

raw.input([param])   #[param] 为提示语 可不写

同一行显示多条语句时，使用分号(;)进行分割

---

python2与python3的不同点
xrange()函数为python2中的函数，python3中已移除了该函数统一使用range(),当在pyhon3中使用xrange()时会提示如下错误信息：** python NameError: name ‘xrange’ is not defined**

thread为python2中的模块,python3中该模块的名称改为了_thread

Sublime 下使用python输出中文时提示
UnicodeEncodeError: ‘ascii’ codec can’t encode characters in position

解决方法：
Preferences > Browse Packages > User > Python3.sublime-build
“env”: {“LANG”: "en_US.UTF-8”}

VS code 控制台输出中文乱码

sys.stdout=io.TextIOWrapper(sys.stdout.buffer,encoding='utf8')

---

pip官网

安装第三方模块

pip install xxx  #python2
pip3 install xxx #python3

查看已安装的第三方某块

pip3 list #python3

第三方库
Beautiful Soup 网页解析

---

在python开发交互环境中可以利用_获取上一次操作的结果

>>> width = 2
>>> height = 3
>>> width * height
6
>>> width * _
12

Python保留字符(所有关键字只包含小写字母):

—	—	—
and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

变量

变量没有数据类，在实践中建议一个变量只引用一种数据类型的对象

比较

== : 比较两个对象的值是否相等，其否定形式 !=
is : 比较两个对象是否为同一个对象，其否定形式 is not

数字

• 整数

  1. 直接创建整数变量
  2. 使用内置函数int()创建整数变量

  int()返回的是一个十进制的整数，当无参数时返回零，只传递一个参数时将该参数转换为整数，若有两个参数则第一个参数必须是字符串而第二个参数指定第一个参数对应的进制

• 浮点数

  1. 直接创建浮点数变量
  2. 使用内置函数float()创建浮点数变量

  float()返回的是一个十进制的小数，当无参数时返回0.0，仅传递一个参数时将该参数转换为浮点数。

  浮点数计算时存在误差，可以使用decimal或fractions模块来进行运算

  from decimal import Decimal
  from fractions import Fraction
  
  print(1.1 + 2.2 - 3.3) #4.440892098500626e-16
  print(Decimal('1.1') + Decimal('2.2') - Decimal('3.3')) #0.0 Decimal中参数需为字符串
  print(Fraction(11,10) + Fraction(22,10) - Fraction(33,10)) #0
  

布尔值：False 、True

True 的数字值为1(含浮点数)
False 的数字值为0(含浮点数)

布尔值基本操作： and、or 、not

and

Python中使用and替代了其它语言(如：Java)中的&&(短路逻辑与),当第一个参数为true(参数值等效于true)时才对第二个参数进行验证,若第一个参数为false(参数值等效于false),则返回第一个参数的值,否则返回第二个参数的值

or

Python中使用or替代了其它语言(如：java)中的||(短路逻辑或),当第一个参数为false(参数值等效于false)时才对第二个参数进行验证,若第一个参数为true(参数值等效于true),则返回第一个参数的值,否则返回第二个参数的值

not

Python中使用not替代了其它语言(如：Java)中的!(逻辑非), 如 not True 的结果为False, not a==b 可以理解为not (a==b),但是不可以写成 a==not b,因为not的优先级比非布尔操作符(除and、or、not外的操作符)的优先级低

在条件判断语句中等效于False的值

None
False
0(任何数字类型的0,如：0,0L,0.0,0j)
''(空字符串)
[]、()、{} (空列表、元组、元字典)

>>> True and False          #双目运算符,返回第二个参数
False
>>> False and True          #返回第一个参数
False
>>> True or False            #双目运算符,返回第一个参数
True
>>> False or True            #返回第二个参数
True
>>> not False                  #单目运算符
True
>>> 1 and  {}                   #当第一个参数等效于true时，返回第二个参数
{}
>>> 0 and 1                    #当第一个参数等效于false时，返回第一个参数
0
>>> 'null' or 0                  #当第一个参数等效于true时，返回第一个参数
'null'
>>> 0 or 'null'                  #当第一个参数等效于false时，返回第二个参数
'null'
>>> not None
True

字符串：字符串由单引号(’’)、双引号("")、三个引号(’’’ 或 “”")构成

>>> name = "name" #定义变量name,并赋值为"name"
>>> name          #输出变量name的值
'name'            #Python输出字符串，使用单引号('')包裹

>>> name = 'name'
>>> name
'name'

>>> name='''what
... is
... your
... name?'''
>>> name
'what\nis\nyour\nname?'  #out:what is your name?  \n为换行符

字符串基本操作：

>>> s = 'ilovepython' #定义变量并初始化
>>> s[1:5]            #获取字符串中下标为1(含)到下标为5(不含)的字符串
'love'
>>> s * 2             #输出字符串两次
'ilovepythonilovepython'
>>> s + "TEST"        #字符串拼接
'ilovepythonTEST'     
>>> s[0:-10]          #负数表示从右到左，最右边对应的是-1，最左边对应的是0  s[0:-10] 等效于 s[0:1]
'i'
>>> s[0:-1]           #等效于 s[0:10]
'ilovepytho'
>>> s[-11:-1]         #等效于 s[0:10]
'ilovepytho'
>>> len(s)            #计算字符串长度
11

列表(list)

Python内置的一种数据类型,使用[]标识,有序集合,支持字符、数字，元素的类型可以不相同，列表可以嵌套列表

元组(tuple)

Python内置的一种数据类型,使用()标识,类似于list列表,不能进行二次赋值

元字典(dictionary)

Python内置的一种数据类型,使用{}标识,无序集合,字典由索引(key)和它对应的值value组成

>>> list = ['Python',2,True]
>>> list
['Python', 2, True]
>>> list[0]
'Python'
>>> list[2] = 5
>>> list
['Python', 2, 5]
>>> list.append(False)                     #追加元素
>>> list
['Python', 2, 5, False]
>>> len(list)                              #获取列表长度
4
>>> list = ['Python', 2, 5, False]
>>> list[-1]
False
>>> list.insert(0,'how')                   #在指定位置插入元素
>>> list
['how', 'Python', 2, 5, False]
>>> list.pop()                             #移除最后一个元素,并将该元素返回
False
>>> list
['how', 'Python', 2, 5]                    #最后一个元素已被移除
>>> list.pop(0)                            #移除指定位置的元素,并将该元素返回
'how'
>>> list
['Python', 2, 5]                           #下标为0的元素已被移除
>>> number = [0,1,3]
>>> number
[0, 1, 3]
>>> list.insert(0,number)
>>> list
[[0, 1, 3], 'Python', 2, 5]
>>> list[0][2]
3

因为()既可以表示Python中的tuple(元组),又可以表示数学公式中的小括号,会产生歧义,所以Python规定,(1)这种写法按小括号计算,(1,)这种写法按元组计算,即元组中只有一个元素时,必须在元素后面加上[,]

>>> tuple = (1)          #一个元素,按小括号计算
>>> tuple
1
>>> tuple = (1,)         #一个元素,按元组计算,元素后面必须加上[,]
>>> tuple
(1,)
>>> tuple = ()           #空元组
>>> tuple
()
>>> tuple = (1,2,3,4)    #非空元组
>>> tuple
(1, 2, 3, 4)
>>> tuple[0]             #获取元组中下标为0的元素
1
>>> t = ('a','b',['A','B'])          #元组中含有列表
>>> t
('a', 'b', ['A', 'B'])
>>> t[0]
'a'
>>> t[2]
['A', 'B']
>>> t[2][0]='c'                      #修改['A','B']中的第一个元素
>>> t[2]
['c', 'B']
>>> t
('a', 'b', ['c', 'B'])               #元组中列表元素的被成功修改了

列表转字符串的两种方式

1 利用join()函数
     li = ['a', 'b', 'c', 'd']
     s = "".join(li)
     print(s)          ／／abcd

2 利用占位符
     s = '%s%s%s%s' % tuple(li)
     print(s)          ／／abcd

网络资料补充：

这个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本身是可变的！

>>> dict = {}                              #空字典
>>> dict
{}
>>> dict['name'] = 'company'               #key:'name',value:'company'
>>> dict
{'name': 'company'}
>>> dict.keys()
['name']
>>> dict['age'] = 21
>>> dict
{'age': 21, 'name': 'company'}
>>> dict.keys()                            #获取字典中全部的key值
['age', 'name']
>>> dict.values()                          #获取字典中全部的value值
[21, 'company']
>>> dict['age']                            #取值
21
>>> dict['age'] = 40                       #一个key对应一个value,重复赋值,会覆盖上一次的值
>>> dict['age']
40
>>> 'age' in dict                          #判断字典中是否含有指定的key值
True
>>> 'aeg' in dict
False
>>> dict.get('age',-1)                     #获取字典中指点key值对应的value值,若该key值不存在,则返回默认值(第二个参数)
40
>>> dict.get('aeg',-1)
-1
>>> dict.pop('age')                        #移除指定元素
40
>>> dict
{'name': 'company'}

网络资料补充：
请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而增加；
2. 需要占用大量的内存，内存浪费多。
   而list相反：
3. 查找和插入的时间随着元素的增加而增加；
4. 占用空间小，浪费内存很少。
   所以，dict是用空间来换取时间的一种方法。
   dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。
   这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

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

流程控制：

条件语句(Python 不支持switch语句)：

>>> age = 20
>>> if age >= 6:             #if 一个或多个
...     'teenager'
... elif age >= 18:          #elif 0个或多个
...     'adult'
... else:                    #else 0个或一个
...     'kid'
...
'teenager'

循环语句(for循环、while循环):

break:退出循环
continue:跳过当前循环的剩余语句,继续执行下一轮循环

>>> fruits = ['banana','apple','mango']
>>> for index in range(len(fruits)):
...     fruits[index]
...
'banana'
'apple'
'mango'

>>> num = 3
>>> while num >= 0:
...     num
...     num -= 1            #Python不支持 ++  -- 操作
...
3
2
1
0

>>> count = 0
>>> while count < 5:
...    print count, " is  less than 5"
...    count = count + 1
... else:                                   #else中的语句会在循环正常执行完成(即for不是通过break跳出而中断)的情况下执行
...    print count, " is not less than 5"
...
0  is  less than 5
1  is  less than 5
2  is  less than 5
3  is  less than 5
4  is  less than 5
5  is not less than 5

>>> i = 1
>>> while i < 10:
...     i += 1
...     if i%2 > 0:     # 非双数时跳过输出
...         continue
...     print i         # 输出双数2、4、6、8、10
...
2
4
6
8
10

>>> i = 1
>>> while 1:            # 循环条件为1必定成立
...     print i         # 输出1~10
...     i += 1
...     if i > 10:      # 当i大于10时跳出循环
...         break
...
...
1
2
3
4
5
6
7
8
9
10

函数：必选参数，默认参数，可变参数，关键字参数

>>> def add(x,y):          #必选参数
...     return x+y
...
>>> add(1,2)
3

>>> def add(x,y=2):         #默认参数 y=2,必选参数要放在默认参数前面
...     return x+y
...
>>> add(3)
5
>>> add(3,1)
4

>>> def add(x=1,y=2):       #默认参数 多个默认参数不按固定位置传值需要指定参数名称,默认参数必须指向不变参数
...     return x+y
...
>>> add()
3
>>> add(y=3)
4
>>> add(x=2)
4

>>> def add(*param):         #可变参数 函数内部接收的是tuple(元组)
...     for n in param:
...             print n
...
>>> add(1,2)
1
2
>>> add(1,2,3,4)
1
2
3
4

>>> def add(*numbers):          #可变参数 参数在函数内部被转化为tuple
...     for n in numbers:
...             print n
...
>>> numbers = [1,2,3]
>>> add(*numbers)               #在list(列表)、tuple(元组)前面添加[*],可使list、tuple变成可变参数
1
2
3
>>> numbers = [2,3,4]
>>> add(*numbers)
2
3
4

>>> def person(name,age,**addition):     #关键字参数 参数在函数内部被转换为dictionary
...     print addition
...
>>> person('n1',12,addr='addr1',tel='1232')
{'tel': '1232', 'addr': 'addr1'}
>>> addition = {'addr':'addr1','tel':'1232'}
>>> person('n1',12,**addition)           #在dictionary前面添加[**],可使dictionary变成关键字参数
{'tel': '1232', 'addr': 'addr1'}

在函数中同时使用多种类型的参数时,须按固定顺序定义参数,必选参数、默认参数、可变参数、关键字参数
函数可以返回多个值，返回的多个值是以tuple(元组)的方式保存的，可以用多个变量接收返回值，按位置一一对应
有多个默认参数时可以按顺序一一对应，也可以通过名称一一对应

a,b = getTwoNumberSquare(5,10)
print(a,b)                      #25 100
#
def add_end(L=[]):
    L.append("end")
    return L

add_end()
add_end()
print(add_end())                #['end', 'end', 'end’]

def add_number(i = 1):
    i+=1
    return i

add_number()
add_number()
print(add_number())            #2

迭代

>>> diction = {'a':1,'b':2}
>>> for key in diction:          #遍历元字典,默认遍历的是key值
...     key
...
'a'
'b'
>>> for key in diction.itervalues():     #遍历元字典中的value
...     key
...
1
2
>>> for key,value in diction.iteritems():  #同时遍历元字典中的key、value
...     key,value
...
('a', 1)
('b', 2)

使用 collection模块中的Iterable类型判断对象是否可迭代

>>> from collections import Iterable
>>> isinstance('abc',Iterable)          #对象可迭代
True
>>> isinstance(234,Iterable)            #对象不可迭代
False

>>> for i in enumerate(list):          
...     i
...
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)

列表生成式

语法：[x for x in list condition or loop]

>>> list(range(1,11))                    #生成简单列表
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> range(1,11)                              
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> [x for x in range(1,11) if x%2==0 ]     #返回能被2整除的元素 condition
[2, 4, 6, 8, 10]

>>> [m+n for m in 'abc' for n in 'XYZ']     #使用多层循环 loop
['aX', 'aY', 'aZ', 'bX', 'bY', 'bZ', 'cX', 'cY', 'cZ']

>>> [x for x in range(1,11) if x%2==0  if x!=4]          #列表生成式嵌套列表生成式
[2, 6, 8, 10]
>>> [x+1 for x in range(1,11) if x%2==0  if x!=4]
[3, 7, 9, 11]
>>> [x for x in [x+1 for x in range(1,11) if x%2==0  if x!=4] ]
[3, 7, 9, 11]
>>> [x for x in [x+1 for x in range(1,11) if x%2==0  if x!=4] if x%3==0]
[3, 9]

高阶函数

map(function,iterable):将函数依次作用到序列的每个元素，并把结果作为新的Iterator

>>> def f(x):
...     return x*x
...
>>> r = map(f,range(1,11))
>>> r
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

reduce(function,iterable):将函数作用在一个序列上，这个函数必选接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

>>> def add(x,y):
...     return x+y
...
>>> reduce(add,range(1,11))
55

filter(function,iterable):把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

>>> def is_odd(n):
...     return n%2==0
...
>>> filter(is_odd,range(1,11))
[2, 4, 6, 8, 10]

sorted函数

>>> sorted([23,58,96,26])
[23, 26, 58, 96]
>>> def reversed_cmp(x,y):          #自定义排序函数
...     if x>y:
...             return -1
...     if x<y:
...             return 1
...     return 0
...
>>> sorted([26,73,28,51],reversed_cmp)          #使用自定义排序函数
[73, 51, 28, 26]

返回函数

>>> def lazy_sum(*args):          #调用lazy_sum每次都返回新函数 
...     def sum():
...             ax = 0
...             for n in args:
...                     ax = ax + n
...             return ax
...     return sum
...
>>> f = lazy_sum(1,3,5,7,9)
>>> f
<function sum at 0x01769970>
>>> f()
25

类的构造函数
init(self,[args…]) //__是由两个下划线构成

网络资料

当直接运行当前.py文件时 name 的值为’main’
当将.py文件作为模块导入到其它文件中时__name__的值为文件名(无后缀)