Python学习笔记
最近在学习python，把学习的过程记录下来，方便以后查看
1. 学习资料
菜鸟教程
Python官网
Python论坛
廖学峰的官方网站
2. 开发环境
因为在mac上做开发，系统自带了2.7的python版本。官网目前python最新版本为3.6.
2.x和3.x语法上有不同，既然刚开始学习，果断入手3.6版本。
安装完成后，现在系统中有两个版本的python了。因此修改一下环境变量，在命令行中输入vim ~/.bash_profile
在其中输入以下两行
alias p3="python3"
alias p2="python2"
保存退出，这样在命令行中就可以输入p2或者p3来打开不同版本了
关于IDE的选择，菜鸟教程上也介绍了几种，最受推崇的应该是PyCharm了.但因为是收费版本，而且费用不菲。自己也确实懒得去找破解版了，所以使用SublimeText3。
SublimeText是可以安装插件的，然后将其打造成一个Python的开发利器。插件的事情以后再研究了。
3.Pip包管理工具
安装python时会自动安装pip
可以输入以下命令查看pip版本
pip3 --version
使用方法
pip3 list --outdated 查看哪些包需要更新
pip3 install demjson安装软件包
pip3 install --upgrade SomePackage升级软件包
pip3 uninstall SomePackage卸载软件包
pip3 search SomePackage查找软件包
pip3 show demjson查看软件包详情
pip3 list列出软件包清单
4. 语法
第一个程序
#!/usr/local/bin/python3
#coding=utf-8
print("你好，世界");
在sublime中输入上面三行代码保存。在命令行中进入到文件所在路径。输入
p3 hello.py
即可看到运行结果。
代码说明：
代码第一行表示可执行文件所在路径。因为现在使用的是python3，所以路径为代码中的地址。菜鸟教程中使用的仍是python2.x,因此教程上的路径为#!/usr/bin/python。此行代码作用是可以在路径下直接用./来执行文件
在命令行也可通过以下命令查看结果
chmod +x hello.py
./hello.py
代码第二行表示文件编码为utf-8，如果不写的话在显示中文时会报错。
python标识符
- 所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头,区分大小写；
- 以下划线开头的标识符是有特殊意义的。以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用"from xxx import *"而导入；
- 以双下划线开头的（__foo）代表类的私有成员；
- 以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__() 代表类的构造函数。
行和缩进
Python的代码块不使用大括号来控制类，而是使用缩进来控制
Python语句中一般以新行作为为语句的结束符。
可以使用斜杠（ \）将一行的语句分为多行显示
total = item_one + \
item_two + \
item_three
语句中包含[], {} 或 () 括号就不需要使用多行连接符
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
引号
Python 接收单引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，其中三引号可以由多行组成，编写多行文本的快捷语法
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
注释
# 第一个注释
'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''
"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""
等待用户输入
下面的程序在按回车键后就会等待用户输入."\n"在结果输出前会输出一个新的空行。一旦用户按下 enter(回车) 键退出，其它键显示
#!/usr/local/bin/python3
#coding=utf-8
print("你好，世界");
text = input("\nPress the enter key to exit.\n")
print("output:" + text)
数据类型
Python支持以下五中基本数据类型：
- Numbers（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
- Set(集合)
字符串
s="1234567890"
可以通过下标来截取字符串 p[头下标:尾下标]
p=s[1:5]
print(p)
//p的结果是 2345
“+”是连字符，“*”是重复符号
#!/usr/local/bin/python3
#coding=utf-8
str = 'Hello World!'
print(str) # 输出完整字符串
print(str[0]) # 输出字符串中的第一个字符
print(str[2:5]) # 输出字符串中第三个至第五个之间的字符串
print(str[2:]) # 输出从第三个字符开始的字符串
print(str * 2) # 输出字符串两次
print(str + "TEST") # 输出连接的字符串
输出结果：
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Python列表（List）
#!/usr/local/bin/python3
#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) # 打印组合的列表
以上输出结果：
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
del删除元素
list1 = ['physics', 'chemistry', 1997, 2000];
print(list1)
del list1[2];
print("After deleting value at index 2 : ")
print(list1)
输出结果：
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
Python元组（Tuple）
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
#!/usr/local/bin/python3
#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) # 打印组合的元组
输出结果：
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')
Python字典（Dictionary）
#!/usr/local/bin/python3
#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()) # 输出所有值
输出结果为：
This is one
This is two
{'name': 'john', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['john', 6734, 'sales'])
Python集合(Set)
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key
s = set([1, 1, 2, 2, 3, 3])
print(s)
s.add(4)
print(s)
s.add(4)
print(s)
s.remove(4)
print(s)
输出结果：
{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3, 4}
{1, 2, 3}
Python运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| ** | 幂 | 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 | 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False |
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
if语句
#!/usr/local/bin/python3
#coding=utf-8
num = 5
if num == 3: # 判断num的值
print('boss')
elif num == 2:
print('user')
elif num == 1:
print('worker')
elif num < 0: # 值小于零时输出
print('error')
else:
print('roadman') # 条件均不成立时输出
while语句
i = 1
while i < 10:
i += 1
if i%2 > 0: # 非双数时跳过输出
continue
print(i) # 输出双数2、4、6、8、10
i = 1
while 1: # 循环条件为1必定成立
print(i) # 输出1~10
i += 1
if i > 10: # 当i大于10时跳出循环
break
while...else语句和for...else语句
#!/usr/local/bin/python3
#coding=utf-8
count = 0
while count < 5:
print(count, " is less than 5")
count = count + 1
else:
print(count, " is not less than 5")
for循环
for letter in 'Python': # 第一个实例
print('当前字母 :', letter)
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例
print('当前字母 :', fruit)
print("Good bye!")
通过序列索引迭代
#!/usr/local/bin/python3
#coding=utf-8
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print('当前水果 :', fruits[index])
print("Good bye!")
pass语句
pass 不做任何事情，一般用做占位语句。
#!/usr/local/bin/python3
#coding=utf-8
# 输出 Python 的每个字母
for letter in 'Python':
if letter == 'h':
pass
print('这是 pass 块')
print('当前字母 :', letter)
print("Good bye!")
python转义字符
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
Python字符串格式化
print("My name is %s and weight is %d kg!" % ('Zara', 21) )
输出：
My name is Zara and weight is 21 kg!
日期和时间
import time; # 引入time模块
#获取当前时间戳
ticks = time.time()
print("当前时间戳为:", ticks)
#当前时间戳为: 1486715050.71681
#获取当前时间
localtime = time.localtime(time.time())
print("本地时间为 :", localtime)
#本地时间为 : time.struct_time(tm_year=2017, tm_mon=2, tm_mday=10, tm_hour=16, tm_min=24, tm_sec=10, tm_wday=4, tm_yday=41, tm_isdst=0)
#获取格式化的时间
localtime = time.asctime( time.localtime(time.time()) )
print("本地时间为 :", localtime)
#本地时间为 : Fri Feb 10 16:24:10 2017
# 格式化成2016-03-20 11:45:39形式
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) )
#2017-02-10 16:24:10
# 格式化成Sat Mar 28 22:24:24 2016形式
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) )
#Fri Feb 10 16:24:10 2017
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print(time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
#1459175064.0
元组时间
很多Python函数用一个元组装起来的9组数字处理时间:
| 序号 | 字段 | 属性 | 值 |
|---|---|---|---|
| 0 | 4位数年 | tm_year | 2008 |
| 1 | 月 | tm_mon | 1 到 12 |
| 2 | 日 | tm_mday | 1到31 |
| 3 | 小时 | tm_hour | 0到23 |
| 4 | 分钟 | tm_min | 0到59 |
| 5 | 秒 | tm_sec | 0到61 (60或61 是闰秒) |
| 6 | 一周的第几日 | tm_wday | 0到6 (0是周一) |
| 7 | 一年的第几日 | tm_yday | 1到366 (儒略历) |
| 8 | 夏令时 | tm_isdst | -1, 0, 1, -1是决定是否为夏令时的旗帜 |
获取日历
import calendar
cal = calendar.month(2017, 2)
print("以下输出2017年2月份的日历:")
print(cal)
输出：
February 2017
Mo Tu We Th Fr Sa Su
1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28
函数
语法
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print str;
return;
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
关键字参数
关键字参数使用顺序可以和函数参数声明顺序不一致
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
#调用printinfo函数
printinfo("miki",50) #默认参数调用
printinfo( age=50, name="miki" );#关键字参数调用
默认参数
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
#调用printinfo函数
printinfo( age=50, name="miki" );
printinfo( name="miki" );
不定长参数
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return;
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );
匿名函数
使用lambda关键字来声明匿名函数
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
可变参数
在参数前添加*,将不变参数变为可变参数
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
print(calc(1, 2)) #输出5
print(calc()) #输出0
nums = [1, 2, 3]
print(calc(nums[0], nums[1], nums[2]))
#或者
print(calc(*nums))
#输出均为14
递归函数
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
当执行fact(1000)会发生栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化：尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
代码修改如下
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
Python 模块
support.py
#!/usr/local/bin/python3
#coding=utf-8
def print_func( par ):
print("Hello : ", par)
return
hello.py
#!/usr/local/bin/python3
#coding=utf-8
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Zara")
定位模块
当导入一个模块，Python对模块位置的搜索顺序是：
- 当前目录
- 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
- 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。
- 在Windows系统，典型的PYTHONPATH如下：
set PYTHONPATH=c:\python20\lib; - 在UNIX系统，典型的PYTHONPATH如下：
set PYTHONPATH=/usr/local/lib/python
如果要给全局变量在一个函数里赋值，必须使用global语句。
文件内容操作
#!/usr/local/bin/python3
#coding=utf-8
fo = open("foo.txt", "w+")
print("文件名: ", fo.name)
print("是否已关闭 : ", fo.closed)
print("访问模式 : ", fo.mode)
#print("末尾是否强制加空格 : ", fo.softspace)
fo.write("www.runoob.com!\nVery good site!");
fo.seek(0, 0);
str = fo.read(10);
print("fileContent:" + str)
fo.close()```
**文件目录操作**
import os
重命名文件test1.txt到test2.txt。
os.rename( "test1.txt", "test2.txt" )
删除一个已经存在的文件test2.txt
os.remove("test2.txt")
创建目录test
os.mkdir("testdir")
将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
给出当前的目录
print(os.getcwd())
删除”/tmp/test”目录
os.rmdir( "/tmp/test" )
打开文件，若文件不存在，则关闭文件 相当于try...finally...
with open('/path/to/file', 'r') as f:
print(f.read())
**面向对象**
类的声明和调用.一般类是写在单独的一个文件中
!/usr/local/bin/python3
coding=utf-8
class Employee:
'所有员工的基类'
empCount = 0
def init(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
def del(self):
print("析构函数执行")
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)
**继承**
python支持多重继承
class A: # 定义类 A
.....
class B: # 定义类 B
.....
class C(A, B): # 继承类 A 和 B
.....
你可以使用issubclass()或者isinstance()方法来检测。
- issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
- isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
**分文件组织源码**
firstClass.py
!/usr/local/bin/python3
coding=utf-8
class firstClass(object):
"""docstring for firstClass"""
def init(self, arg):
super(firstClass, self).init()
self.arg = arg
def printMe(self):
print(__name__)
secondClass.py
!/usr/local/bin/python3
coding=utf-8
class secondClass(object):
"""docstring for secondClass"""
def init(self, arg):
super(secondClass, self).init()
self.arg = arg
def printMe(self):
print(__name__)
hello.py
!/usr/local/bin/python3
coding=utf-8
import firstClass
import secondClass
class1 = firstClass.firstClass('a')
class2 = secondClass.secondClass('a')
class1.printMe()
class2.printMe()
