python学习小记1

Posted 2020-07-09 yxtxiaotian

(1) Python优缺点:

优点:

1.Python有非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，除了内置的库外，Python还有大量的第三方库;

2.Python应用: 首选是网络应用，包括网站、后台服务等等；其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；另外就是把其他语言开发的程序再包装起来，方便使用.

缺点:

1. 第一个缺点就是运行速度慢，和C程序相比非常慢;

2. 第二个缺点就是代码不能加密;

(2) Python安装

采用Python2.7,下面是第一个程序:

# hello.py
print 'hello, world!'
print '100+200 =', 100+200
name = raw_input('please enter your name:')
print '------------------\n', 'hello,', name

# #################################
# print absolute value of an integer:
a = 100
if a >= 0:
    print a
else:
    print -a
    
# #################################

(3)Python数据类型

1. 整数

2. 浮点数

3. 字符串:

# 转义字符\.
'I\'m \"OK\"!'
# 表示的字符串内容是：
I'm "OK"!
# 如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容
>>> print '''line1
... line2
... line3'''
# 上面是在交互式命令行内输入，如果写成程序，就是：
print '''line1
line2
line3'''

4. 布尔值: True, False；布尔值可以用and、or和not运算;

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

6. 变量:

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量;这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言;

# a是整数
a = 123 
print a
# a变为字符串
a = 'ABC'
print a

理解变量在计算机内存中的表示也非常重要。当我们写：

a = ‘ABC‘

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

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

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

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：

a = 'ABC'
b = a
a = 'XYZ'
print b

最后一行打印出变量b的内容到底是‘ABC‘呢还是‘XYZ‘？如果从数学意义上理解，就会错误地得出b和a相同，也应该是‘XYZ‘，但实际上b的值是‘ABC‘，让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行a = ‘ABC‘，解释器创建了字符串‘ABC‘和变量a，并把a指向‘ABC‘：

执行b = a，解释器创建了变量b，并把b指向a指向的字符串‘ABC‘：

执行a = ‘XYZ‘，解释器创建了字符串‘XYZ‘，并把a的指向改为‘XYZ‘，但b并没有更改：

所以，最后打印变量b的结果自然是‘ABC‘了。

7. 常量

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

PI = 3.14159265359

但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

最后解释一下整数的除法为什么也是精确的，可以试试：

>>> 10 / 3
3

你没有看错，整数除法永远是整数，即使除不尽。要做精确的除法，只需把其中一个整数换成浮点数做除法就可以：

>>> 10.0 / 3
3.3333333333333335

因为整数除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

>>> 10 % 3
1

无论整数做除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

(4) 字符串和编码

1. ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65，二进制的01000001；

字符0用ASCII编码是十进制的48，二进制的00110000，注意字符‘0‘和整数0是不同的；

汉字中已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。

你可以猜测，如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。

新的问题又出现了：如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：

字符	ASCII	Unicode	UTF-8
A	01000001	00000000 01000001	01000001
中	x	01001110 00101101	11100100 10111000 10101101

2. 在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：

浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />的信息，表示该网页正是用的UTF-8编码。

3. Python提供了ord()和chr()函数，可以把字母和对应的数字相互转换：

>>> ord('A')
65
>>> chr(65)
'A'

4. 把u‘xxx‘转换为UTF-8编码的‘xxx‘用encode(‘utf-8‘)方法：

>>> u‘ABC‘.encode(‘utf-8‘)
‘ABC‘
>>> u‘中文‘.encode(‘utf-8‘)
‘\xe4\xb8\xad\xe6\x96\x87‘

5. 反过来，把UTF-8编码表示的字符串‘xxx‘转换为Unicode字符串u‘xxx‘用decode(‘utf-8‘)方法：

>>> ‘abc‘.decode(‘utf-8‘)
u‘abc‘
>>> ‘\xe4\xb8\xad\xe6\x96\x87‘.decode(‘utf-8‘)
u‘\u4e2d\u6587‘
>>> print ‘\xe4\xb8\xad\xe6\x96\x87‘.decode(‘utf-8‘)
中文

6. 由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

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

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

7. 格式化字符串的方式

# %d	整数
# %f	浮点数
# %s	字符串
# %x	十六进制整数
# 如果只有一个%?，括号可以省略
print 'Hello, %s' % 'world'
print 'Hi, %s, you have $%d.' % ('xiaotian', 1000000)
print '%10d-%08d' % (3, 1)
print '%.4f' % 3.1415926
# 用%%来表示一个%
print 'growth rate: %d%%' % 7
# 对于Unicode字符串，用法完全一样
print u'Hi, %s' % u'xiaotian'

(5) list和tuple

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素:

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
# ['Michael', 'Bob', 'Tracy']
# 变量classmates就是一个list。用len()函数可以获得list元素的个数：
>>> len(classmates)
# 3
# 用索引来访问list中每一个位置的元素，记得索引是从0开始的：
>>> classmates[0]
# 'Michael'
# 记得最后一个元素的索引是len(classmates) - 1。
# 如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：
>>> classmates[-1]
# 'Tracy'
# 以此类推，可以获取倒数第2个、倒数第3个：
>>> classmates[-2]
# 'Bob'
# list是一个可变的有序表，所以，可以往list中追加元素到末尾：
>>> classmates.append('Adam')
>>> classmates
# ['Michael', 'Bob', 'Tracy', 'Adam']
# 也可以把元素插入到指定的位置，比如索引号为1的位置：
>>> classmates.insert(1, 'Jack')
>>> classmates
# ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
# 要删除list末尾的元素，用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

tuple

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

>>> classmates = ('Michael', 'Bob', 'Tracy')
# 现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
# 不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
# 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本身是可变的！

(6) 条件判断和循环

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else，所以，请测试并解释为什么下面的程序打印的是teenager：

age = 20
if age >= 6:
    print ‘teenager‘
elif age >= 18:
    print ‘adult‘
else:
    print ‘kid‘

循环

Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来，看例子：

names = [‘Michael‘, ‘Bob‘, ‘Tracy‘]
for name in names:
    print name

执行这段代码，会依次打印names的每一个元素.for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句。

range(101)就可以生成0-100的整数序列，计算如下：

sum = 0
for x in range(101):
    sum = sum + x
print sum

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print sum

在循环内部变量n不断自减，直到变为-1时，不再满足while条件，循环退出。

最后看一个有问题的条件判断。很多同学会用raw_input()读取用户的输入，这样可以自己输入，程序运行得更有意思：

birth = raw_input(‘birth: ‘)
if birth < 2000:
    print ‘00前‘
else:
    print ‘00后‘

输入1982，结果却显示00后，这么简单的判断Python也能搞错？

当然不是Python的问题，在Python的交互式命令行下打印birth看看：

>>> birth
‘1982‘
>>> ‘1982‘ < 2000
False
>>> 1982 < 2000
True

原因找到了！原来从raw_input()读取的内容永远以字符串的形式返回，把字符串和整数比较就不会得到期待的结果，必须先用int()把字符串转换为我们想要的整型：

birth = int(raw_input(‘birth: ‘))

再次运行，就可以得到正确地结果。当然了,输入的数据是要可以转换成数字的.

(7) 使用dict和set

dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
# 95
>>> d['Jack'] = 90
>>> d['Jack']
# 90
>>> d['Jack'] = 88
>>> d['Jack']
# 88

如果key不存在，dict就会报错. 要避免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放入的顺序是没有关系的。

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

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

而list相反：

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

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

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

set

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

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

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

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

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

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

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

>>> s.add(4)
>>> s
set([1, 2, 3, 4])
>>> s.add(4)
>>> s
set([1, 2, 3, 4])

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

>>> s.remove(4)
>>> s
set([1, 2, 3])

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

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])

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

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

[截自]http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000