python小学日志

若是没有特殊业务要求，请牢记仅使用UTF-8编码。

在Mac和Linux上是能够的，方法是在.py文件的第一行加上一个特殊的注释：

#!/usr/bin/env python3

print('hello, world')

而后，经过命令给hello.py以执行权限：

$ chmod a+x hello.py

就能够直接运行hello.py了

若是字符串里面有不少字符都须要转义，就须要加不少\，为了简化，Python还容许用r''表示''内部的字符串默认不转义

布尔值能够用and、or和not运算。

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

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

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

 

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

a = 'ABC'

时，Python解释器干了两件事情：

1. 在内存中建立了一个'ABC'的字符串；

2. 在内存中建立了一个名为a的变量，并把它指向'ABC'。

也能够把一个变量a赋值给另外一个变量b，这个操做其实是把变量b指向变量a所指向的数据

 

数据类型

Python 定义了一些标准类型，用于存储各类类型的数据。

Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典)

Python数字

数字数据类型用于存储数值。

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

当你指定一个值时，Number对象就会被建立：

var1 = 1
var2 = 10

也可使用del语句删除一些对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您能够经过使用del语句删除单个或多个对象的引用。例如：

del var
del var_a, var_b

Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

若是你要实现从字符串中获取一段子字符串的话，可使用变量 [头下标:尾下标]，就能够截取相应的字符串，其中下标是从 0 开始算起，能够是正数或负数，下标能够为空表示取到头或尾。

好比:

s = 'ilovepython'

s[1:5]的结果是love。

当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。

加号（+）是字符串链接运算符，星号（*）是重复操做。以下实例(paython2.0+)：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
str = 'Hello World!'
 
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出链接的字符串

 

Python列表

List（列表） 是 Python 中使用最频繁的数据类型。

列表能够完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至能够包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也能够用到变量 [头下标:尾下标] ，就能够截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标能够为空表示取到头或尾。

若是要取最后一个元素，除了计算索引位置外，还能够用-1作索引，直接获取最后一个元素

加号 + 是列表链接运算符，星号 * 是重复操做

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的全部元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

Python元组

元组是另外一个数据类型，相似于List（列表）,可是tuple一旦初始化就不能修改,tuple所谓的“不变”是说，tuple的每一个元素，指向永远不变。即指向'a'，就不能改为指向'b'，指向一个list，就不能改为指向其余对象，但指向的这个list自己是可变的！

元组用"()"标识。内部元素用逗号隔开。

>>> 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,)

可是元组不能二次赋值，至关于只读列表。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple               # 输出完整元组
print tuple[0]            # 输出元组的第一个元素
print tuple[1:3]          # 输出第二个至第三个的元素 
print tuple[2:]           # 输出从第三个开始至列表末尾的全部元素
print tinytuple * 2       # 输出元组两次
print tuple + tinytuple   # 打印组合的元组

Python 字典

字典(dictionary)是除列表之外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

二者之间的区别在于：字典当中的元素是经过键来存取的，而不是经过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

须要牢记的第一条就是dict的key必须是不可变对象

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出全部键
print tinydict.values()    # 输出全部值

把数据放入dict的方法，除了初始化时指定外，还能够经过key放入,若是key不存在，dict就会报错,要避免key不存在的错误，有两种办法，

一是经过in判断key是否存在

>>> 'Thomas' in d
False

二是经过dict提供的get()方法，若是key不存在，能够返回None，或者本身指定的value

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

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

>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

 

set

set能够当作数学意义上的无序和无重复元素的集合，所以，两个set能够作数学意义上的交集、并集等操做

set和dict的惟一区别仅在于没有存储对应的value，可是，set的原理和dict同样，因此，一样不能够放入可变对象，由于没法判断两个可变对象是否相等，也就没法保证set内部“不会有重复元素”

要建立一个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}

 

函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，而后，在缩进块中编写函数体，函数的返回值用return语句返回

空函数

若是想定义一个什么事也不作的空函数，能够用pass语句：

def nop():
    pass

返回多个值

原来返回值是一个tuple！可是，在语法上，返回一个tuple能够省略括号，而多个变量能够同时接收一个tuple，按位置赋给对应的值，因此，Python的函数返回多值其实就是返回一个tuple

11.函数参数

位置参数

默认参数

设置默认参数时，有几点要注意：

一是必选参数在前，默认参数在后，不然Python的解释器会报错（思考一下为何默认参数不能放在必选参数前面）；

二是如何设置默认参数。

当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就能够做为默认参数。

有多个默认参数时，调用的时候，既能够按顺序提供默认参数，好比调用enroll('Bob', 'M', 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数因为没有提供，仍然使用默认值。

也能够不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，须要把参数名写上。

默认参数必须指向不变对象

可变参数

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple

Python容许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去

关键字参数

可变参数容许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数容许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

**extra表示把extra这个dict的全部key-value用关键字参数传入到函数的**kw参数，kw将得到一个dict，注意kw得到的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra

若是要限制关键字参数的名字，就能够用命名关键字参数，例如，只接收city和job做为关键字参数。这种方式定义的函数以下：

def person(name, age, *, city, job):
    print(name, age, city, job)

和关键字参数**kw不一样，命名关键字参数须要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

调用方式以下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

若是函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就再也不须要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不一样。若是没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

使用命名关键字参数时，要特别注意，若是没有可变参数，就必须加一个*做为特殊分隔符。若是缺乏*，Python解释器将没法识别位置参数和命名关键字参数：

def person(name, age, city, job):
    # 缺乏 *，city和job被视为位置参数
    pass

参数组合

在Python中定义函数，能够用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数均可以组合使用。可是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

 

高级特性

列表生成式

列表生成式即List Comprehensions,Python内置的能够用来建立list的生成式

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就能够把list建立出来

for循环后面还能够加上if判断，这样咱们就能够筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可使用两层循环，能够生成全排列：

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

生成器

Python中，这种一边循环一边计算的机制，称为生成器：generator。

要建立一个generator，有不少种方法。

1、第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

咱们建立了一个generator后，基本上永远不会调用next()，而是经过for循环来迭代它，而且不须要关心StopIteration的错误

2、

若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator：

>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代

可是用for循环调用generator时，发现拿不到generator的return语句的返回值。若是想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

>>> g = fib(6)
>>> while True:
...     try:
...         x = next(g)
...         print('g:', x)
...     except StopIteration as e:
...         print('Generator return value:', e.value)
...         break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done