python 基础 day2

字符编码

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

ASCII(American Standard Code for Information Interchange,美国标准信息交换代码)是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言，其最多只能用8位来表示（一个字节），即：2**8=256-1，所以，ASCII码最多只能表示255个符号。

所以推出一种新的可以代表所有字符和符号的编码，即：　Unicode 规定所有的字符和符号最少由16位来表示（2个字节），即：2**8＝65536

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

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

注释

当行注释：＃被注释的内容

多行注释：''' 被注释的内容''' ＃多行显示三个单引号和三个多引号都可以

模块初识

test.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
print(sys.argv)
#输出
$python test.py hellp world

['test.py','hello','world'] ＃把执行脚本的参数获取到了

import os
os.system("df -Th") #调用系统命令

自己写个模块

python tab补全模块

for Mac

tab.py
#!/usr/bin/env python
import sys
import deadline
import rlcompleter

if sys.platform == 'darwin' and sys.version_info[0] == 2:
    redline.parse_and_bind("bind ^I rl_completer")
else:
    redline.parse_and_bind("tab: completer") #linux and python on mac

for Linux

#!/usr/bin/env python 
# python startup file 
import sys
import readline
import rlcompleter
import atexit
import os
# tab completion 
readline.parse_and_bind('tab: complete')
# history file 
histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
try:
    readline.read_history_file(histfile)
except IOError:
    pass
atexit.register(readline.write_history_file, histfile)
del os, histfile, readline, rlcompleter

for Linux

View Code

写完保存就可以使用

>>>import tab

你会发现，上面自己写的模块只能在当前目录下导入，如果想在系统的任何一个地方都使用，你就要把这个tab.py放到python全局变量环境目录里，基本一半都放在一个叫Python/2.7/site-packages目录下，这个目录在不同的OS里放的位置不一样，用print(sys.path) 可以查看python环境变量的列表。

.pyc是个什么鬼？

1、解释型语言和编译型语言

计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释。

编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。

解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。

通过以上的例子，我们可以来总结一下解释型语言和编译型语言的优缺点，因为编译型语言在程序运行之前就已经对程序做出了“翻译”，所以在运行时就少掉了“翻译”的过程，所以效率比较高。但是我们也不能一概而论，一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。

此外，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种。

用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

2、简述Python的运行过程

在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。

我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。（如果.py被改变，先会比较 .py 和.pyc 最新修改时间。）。我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式

数据类型初识

1、数字

2 是一个整数的例子。
长整数不过是大一些的整数。
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
(-5+4j)和(2.3-4.6j)是复数的例子。

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（复数）
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

2、布尔值

　　真或假

　　1 或 0

3、字符串

万恶的字符串，每次创建字符串时候需要在内存中开辟一块连续的空间，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

name = "QL"
print("my name is"+name+"and you?")   #开辟了3块内存空间
print("my name is %s and you?")%name  #开辟了1块内存空间

方法（1）
# split()把字符串分割成列表
name = "Peter,John,QL,Jack"
name2 = name.split(",")
print(name2)   #输出 ['Peter', 'John', 'QL', 'Jack']

#多个符号作为分隔符
address = "上海^上海市@闵行区#吴中路";
splitAddress = address.split("\\^|@|#"); 

#总结：（1）split表达式，其实就是一个正则表达式。 * ^ | 等符号在正则表达式中属于一种有特殊含义的字符，如果使用此种字符作为分隔符，必须使用转义符即\\加以转义。 
#     （2）如果使用多个分隔符则需要借助 | 符号，如上所示，但需要转义符的仍然要加上分隔符进行处理。

方法(1) split()

name = "QL"
print(name.center(40,"#")) #40是字符串的长度，# 是填充符
#运行结果 
# ###################QL###################

方法(2) center()

#查找子字符串，若找到返回从0开始的下标值，若找不到返回-1

name = "QLQin"
print(name.find('Q')) #从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
print(name.find('Q',1))#从下标1开始，查找在字符串里第一个出现的子串：返回结果2
print(name.find('33'))#返回-1,查找不到返回-1

方法(3) find()

#声明：s为字符串，rm为要删除的字符序列
#s.strip(rm)        删除s字符串中开头、结尾处，位于 rm删除序列的字符
#s.lstrip(rm)       删除s字符串中开头处，位于 rm删除序列的字符
#s.rstrip(rm)      删除s字符串中结尾处，位于 rm删除序列的字符
#注意：
#1. 当rm为空时，默认删除空白符（包括'\n', '\r',  '\t',  ' ')

>>> a = '     123'
>>> a.strip()
'123'
>>> a='\t\r\nabc'  #当rm为空时默认删除空白符（包括'\n','\r','\t',' ’）
'abc'

#这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉。
>>> a = '123abc'
>>> a.strip('21')
'3abc'   结果是一样的
>>> a.strip('12')
'3abc'

方法(4) strip()

#返回字符串的一个副本，只有它的第一个字母大写。对于8位的字符串，这个方法与语言环境相关。
name ="qinling"
print(name.capitalize()) #返回Qinling

方法(5) capitalize()

#使用str.format()函数   
#使用'{}'占位符  
print('I\'m {},{}'.format('Hongten','Welcome to my space!'))  
>>> I'm Hongten,Welcome to my space!  
print('#' * 40)    
#也可以使用'{0}','{1}'形式的占位符  
print('{0},I\'m {1},my E-mail is {2}'.format('Hello','Hongten','hongtenzone@foxmail.com')) 

>>> Hello,I'm Hongten,my E-mail is hongtenzone@foxmail.com

#可以改变占位符的位置 
print('{1},I\'m {0},my E-mail is {2}'.format('Hongten','Hello','hongtenzone@foxmail.com')) 
>>> Hello,I'm Hongten,my E-mail is hongtenzone@foxmail.com
print('#' * 40) 
########################################
#使用'{name}'形式的占位符 
print('Hi,{name},{message}'.format(name = 'Tom',message = 'How old are you?')) 
>>> Hi,Tom,How old are you?
print('#' * 40) 
########################################
#混合使用'{0}','{name}'形式 
print('{0},I\'m {1},{message}'.format('Hello','Hongten',message = 'This is a test message!')) 
>>> Hello,I'm Hongten,This is a test message!
print('#' * 40) 
########################################

方法(6) format ()

#isdigit()方法检查字符串是否只包含数字(全由数字组成)。
返回值
如果字符串中的所有字符都是数字，并至少有一个字符此方法返回true，否则返回false。
#!/usr/bin/python
 
str = "123456"; # Only digit in this string
print str.isdigit();
 
str = "this is string example....wow!!!";
print str.isdigit();

#当我们运行上面的程序，它会产生以下结果：
True
False

方法(7) isdigit()

#isalnum()方法检查判断字符串是否包含字母数字字符
#返回值 如果字符串中的所有字符字母数字和至少有一个字符此方法返回 true，否则返回false。
#!/usr/bin/python

str = "this2009";  # No space in this string
print str.isalnum();

str = "this is string example....wow!!!";
print str.isalnum();

s为字符串
s.isalnum()    #所有字符都是数字或者字母
s.isalpha()    #所有字符都是字母
s.isdigit()    #所有字符都是数字
s.islower()    #所有字符都是小写
s.isupper()    #所有字符都是大写
s.istitle()    #所有单词都是首字母大写，像标题
s.isspace()    #所有字符都是空白字符、\t、\n、\r

#Python endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
#参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
#返回值  如果字符串含有指定的后缀返回True，否则返回False。
#以下实例展示了endswith()方法的实例：
#!/usr/bin/python

str = "this is string example....wow!!!";

suffix = "wow!!!";
print str.endswith(suffix);
print str.endswith(suffix,20);

suffix = "is";
print str.endswith(suffix, 2, 4);
print str.endswith(suffix, 2, 6);
#以上实例输出结果如下：
True
True
True
False

.endswith()

如果你要用python匹配字符串的开头或末尾是否包含一个字符串，就可以用startswith 和 endswith

例如: content = 'ilovepython'

如果字符串content以ilove开始，返回True，否则返回False
则可以用这句脚本进行判断: if content.startswith("ilove") : .......
>>>返回true
if content.startswith("sss") : ......
>>>返回false

同样，如果字符串content以python结尾，返回True，否则返回False
if content.endswith('python') : ...
>>>返回true
if content.endswith("sss") : ..

#Python upper() #方法将字符串中的小写字母转为大写字母。
#!/usr/bin/python

str = "this is string example....wow!!!";
print "str.upper() : ", str.upper()

THIS IS STRING EXAMPLE....WOW!!!

#Python lower() #方法转换字符串中所有大写字符为小写。

str = "THIS IS STRING EXAMPLE....WOW!!!";
print str.lower();

this is string example....wow!!!

.upper()

PS: 字符串是 %s;整数 %d;浮点数%f

字符串常用功能：

移除空白
分割
长度
索引
切片

4、列表

创建列表

列表对应数字是下标，list.sort 3.0 里数字和字符不能一起排序，del 删除内存中的数据，全局使用

name_list = ['alex', 'seven', 'eric']
或
name_list ＝ list(['alex', 'seven', 'eric'])

切片

#切片可以之后再切片
>>> name=[11,22,33,44,55,66]
>>> name[:5][2:4][0]
33

增删改查

增删改查
>>> shopping_list.append('MovieTicket') #向列表后面追加一个元素
>>> shopping_list
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift', 'MovieTicket'] >>> shopping_list.pop() #删除最后一个元素
'MovieTicket'
>>> shopping_list.remove('Mac') #删除叫’Mac’的元素,如果有多个’Mac’,那会删除从左边数找到的第一 个
>>> shopping_list[2]
'Coffee'
>>> shopping_list[2] = 'COFFEE' #将索引为2的元素改为”COFFEE”,原来是小写
>>> shopping_list.insert(3,"Toy") #插入一个新元素,索引为3
>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift']
>>> shopping_list.index('Toy') #返回’Toy’元素的索引值,如果有多个相同元素,则返回匹配的第一个
3
>>> shopping_list.append('Food')
>>> shopping_list.count('Food') #统计’Food’的元素的个数,刚添加了一个,所以现在是2个
2
>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift', 'Food']
>>> list2= ['Banana','Apple'] #创建一个新列表
>>> shopping_list.extend(list2) #把上面的新列表合并到shopping_list中
>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift', 'Food', 'Banana', 'Apple']
>>> shopping_list.sort() #将列表排序
>>> shopping_list
['Apple', 'Banana', 'Bike', 'COFFEE', 'Car', 'Clothes', 'Food', 'Food', 'Gift', 'Iphone', 'Toy']
>>> shopping_list.reverse() #将列表反转
>>> shopping_list
['Toy', 'Iphone', 'Gift', 'Food', 'Food', 'Clothes', 'Car', 'COFFEE', 'Bike', 'Banana', 'Apple']
>>> del shopping_list[3:8] #删除索引3至8的元素,不包括8
>>> shopping_list
['Toy', 'Iphone', 'Gift', 'Bike', 'Banana', 'Apple']
>>> for i in shopping_list: #遍历列表
... print i

基本操作

元素拼接

li = ["a","b","c"]
result = "".join(li)
print(result)
abc

5、元组（不可变）

元组的元素不可变，元素的元素可变（元组的元素可以是字典，字典里的元素可变）

创建元组

ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))

6、字典（无序）

创建字典

person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})

dic = {"name":QL,"age":27,"addr":"jl"}
for key,v in dic.items() #效率低，因为有一个dic to list的过程

＃最好使用：
for key in dic:
    print(key,dic[key])

>>> info['name'] #查看key为’name’的value
'alex'
>>> info['job'] = 'Boss' #将key 的value 改为’Boss’
>>> info
{'age': 29, 'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex'}
>>> info['city'] = 'BJ' #如果dict中有key为’city’,就将其值改为’BJ’,如果没有这个key,就创建一条新 纪录
>>> info
{'age': 29, 'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}
>>> info.pop('age') #删除key为’age’的数据,跟del info[‘age’] 一样
29
>>> info
{'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}
>>> info.popitem() #随机删除一条数据,dict为空时用此语法会报错
('job', 'Boss')
>>> info.items() #将dict的key,value转换成列表的形式显示
[('company', 'AUTOHOME'), ('name', 'alex'), ('city', 'BJ')]
>>> info.has_key('name') #判断字典中是否有个叫’name’的key
True
>>> info['age'] #查找一个不存在的key报错,因为’age’刚才已经删除了,所以报错 Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'age'
>>> info.get('age') #查找key,如果存在则返回其value,否则则返回None
>>> info.get('name')
'alex'
>>> info.clear() #清空dict
>>> info
{}
>>> info.fromkeys(['a','b','c'],'Test') #根据列表[‘a’,’b’,’c’]来创建dict里的key,后面 的’Test’是默认value,如果不指定的话则为None
{'a': 'Test', 'c': 'Test', 'b': 'Test'}
>>> info
{}
>>> info =info.fromkeys(['a','b','c'],'Test')
>>> info
{'a': 'Test', 'c': 'Test', 'b': 'Test'}
>>> info.setdefault('d','Alex') #找一个key为’d’的纪录,如果这个key不存在,那就创建一个叫’d’的key, 并且将其value设置为’Alex’, 如果这个key存在,就直接返回这个key的value,见下一条
'Alex'
>>> info.setdefault('c','Alex')
'Test'
>>> info
{'a': 'Test', 'c': 'Test', 'b': 'Test', 'd': 'Alex'}
>>> dict2 = {'e':'fromDict2','a':'fromDict2'} #创建一个新字典
>>> info.update(dict2) #拿这个新字典去更新info,注意dict2中有一个key值’a’与dict info相冲突,这 时dict2的值会覆盖info中的a,如果dict2的key在info中不存在,则创建相应的纪录
>>> info
{'a': 'fromDict2', 'c': 'Test', 'b': 'Test', 'e': 'fromDict2', 'd': 'Alex'}

增删改查

dict.setdefault(key, default=None)

＃返回值 该方法没有任何返回值

#以下实例展示了 setdefault()函数的使用方法：
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print("Value : %s" %  dict.setdefault('Age', None))
print ("Value : %s" %  dict.setdefault('Sex', None))
＃以上实例输出结果为：
Value : 7
Value : None
print(dic.setdefault("addr":"jl")) #取一个key的值，如果没有就设置一个

dic.setdefault()

dic = {
220382:{'name':'QL',
   'age':22,
   'addr':'jl'},
220341:{'name':'lanlan',
'age':20,
'addr':'henan'},
220352:{'name':'lidan',
'age':21,
'addr':'hangzhou'}
   }

dic.keys()          #取key
dic.values()        #取key对应的值

dic.update(dic2)    #把dic2的更新到dic里
dic.has_key(220382) #only in 2.x 版本
220382 in dic       #等与has_key(x)
dic.get(220382)     #一般用这种方法获取值
dic(220382)         #用这种方法可能会出错

常用操作：