python基础-01

学习python一年多，之前在cnblog上写博客，偶然的机会看到一个上的一篇文章，作者学习能力和笔记方面做的非常好，一来想学习学习，二来可以接触下的博客系统，同时希望可以认识更多更加优秀有趣的朋友！

python编码

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

print('python编码')

Python 变量类型

Python有五个标准的数据类型：Numbers（数字）String（字符串）List（列表）Tuple（元组）Dictionary（字典）

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

num = 10  #数值型
str = 'hello world' #字符串型
list = ['a','b','c',1,2,3]  #列表 可以通过下表(偏移)指定输出列表中的指定元素 从左到右0开始，从右左-1开始
tuple = ('a','b','c',1,2,3) #元组 可以通过下表指定输出列表中的指定元素 从左到右0开始，从右左-1开始 元素不能呗二次赋值 相当于是只读列表
dict = {'name':'mike','age':18} #字典 为无序的对象集合 通过键去访问对应的元素

print(type(num))
print(type(str))
print(type(list))
print(type(tuple))
print(type(dict))

Python数据类型转换

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

print(int(1.1)) # 转换成整型 这里要注意的是转型的字符串仅仅包含数字 要不会报错的

#c = long(b) # python3 之后没有long, 直接采用int转换成整型

print(float(10)) # 转换成浮点型

e = complex(1,2) # 创建一个复数

print(str(10)) # 转换成字符串

print(repr(10)) # 转换为表达式字符串

num1 = 10
num2 = 20
print(eval('num1 + num2'))# 将字符串str当成有效的表达式来求值并返回计算结果

s = ['a','b','c',1,2,3]
print(tuple(s)) # 将序列 i 转换为一个元组

s = ('a','b','c',1,2,3)
print(list(s)) # 将元组 s 转换为一个序列

s = {11,22,33,44}
print(set(s)) # 转换为可变集合

print(dict(one=1,two=2)) # 创建一个字典

print(frozenset(s))  # 转换为不可变集合

print(chr(48)) # chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符

# print(unichr(48))  # python3 没有用unichar函数 直接用chr替换

print(ord(u'\u2345'))  # 将一个字符转换为它的整数值

print(hex(10)) # 将一个整数转换为一个十六进制字符串

print(oct(10)) # 将一个整数转换为一个八进制字符串

Python 运算符

Python算术运算符

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

a = 2
b = 3

print(a + b) #加

print(a - b) #减

print(a * b) #乘

print(a / b) #除

print(a % b) #取模

print(a ** b) #幂 相当于是 a的b次方

print(b // a) #取整除

Python 条件语句

if 判断条件：
执行语句……
else：
执行语句……

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

salary = 20000

if(salary > 15000):
    print('勉强可以养活自己!')
else:
    print('兄弟,回家种田吧!')

python不支持switch， 如果有多种情况的判断的话，可以采用ifelseif实现
if 判断条件：
执行语句……
elif判断条件：
执行语句……

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

salary = 20000

if(salary > 50000):
    print('土豪我们做朋友吧!')
elif(salary > 30000):
    print('小资生活!')
elif(salary > 15000):
    print('勉强可以养活自己!')
else:
    print('兄弟,回家种田吧!')

Python 循环语句

Python for 循环语句

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

#################对字符串的循环读取 #####################
str = '广州';
for i in str:
    print(i)

#################对列表的循环读取 #####################
list = [10,20,30,50]
new_list = []
for i in list:
    if(i >= 19):
        # print(i)
        new_list.append(i)  #追加到新的列表
    # else:
    #     print(i)
    #     list.remove(i)         #删除列表中的元素  这里发现了个问题 如果删除后 列表的偏移量(指针)应该会重新排列，会导致 值为20的在循环中被忽略掉 最好用重新赋值到一个新的列表的形式
print(list)
print(new_list)


#################对元组的循环读取 #####################

tuple = ('a','b','c',1,2,3)
new_tuple = ()
for i in tuple:
    if(isinstance(i,int)):
        print(i)


#################对字典的循环读取 #####################

dict = {'name':'mike','age':18,'job':'engineer'}

for i in dict: #这里的i是字典的key 这里循环输出的顺序很有意思,好像按照key的第一个字母的正序输出
    # print(i)
    print(dict[i])

for key,value in dict.items(): # 对键和值都进行遍历
    print(key)
    print(value)

Python While循环语句

a = 10
b = 20

while(a < b):
    print(a)
    a = a +1

Python 循环嵌套

#!/usr/bin/python
# -*- coding: UTF-8 -*-

i = 2
while(i < 100):
   j = 2
   while(j <= (i/j)):
      if not(i%j): break
      j = j + 1
   if (j > i/j) :
       print(i, " 是素数")
   i = i + 1

print("Good bye!")

break 和 continue的区别:break是直接终止整个循环，continue是终止当前次的循环继续下一次循环

#!/usr/bin/python
# -*- coding: UTF-8 -*-

list = ['a','b',1,2,10,30,'c']
for i in list:
    if(isinstance(i,str)):
        print(i)
    else:
        # continue
        break

Python 日期和时间

Time模块

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import time # 引入time模块

print(time.time())  # 返回当前时间的时间戳（1970纪元后经过的浮点秒数）

localtime = time.localtime(time.time())
print ("本地时间为 :", localtime) # 返回当前的时间元组

localtime = time.asctime( time.localtime(time.time()) )
print("本地时间为 :", localtime) # 返回格式化的时间

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))  # 返回自定义的格式日期

日历（Calendar）模块

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import calendar

cal = calendar.month(2016, 1)
print("以下输出2016年1月份的日历:")
print(cal)

Python 函数

函数相当于是封装好的一个代码块，可以提供应用的模块性和代码的重用性，可以分为内置函数和自定义函数
自定义函数的规则：

• 函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

!/usr/bin/python
# -*- coding: UTF-8 -*-
import time

#函数的定义
def myfun():
    print('当前时间是：',time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

#函数的定义
def person(name,age): #name age为变量 可以对其进行初始
    print('名字:',name,'年龄',age)

#函数的调用
myfun()

#函数的调用
person('mike',18)

按值传递参数和按引用传递参数：
所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变

#!/usr/bin/python
# -*- coding: UTF-8 -*-

def changeParameter(data):
    data.append(123)
    print('函数内的参数:',data) #函数内的参数

data = [10,20]
changeParameter(data)

print('函数外的参数:',data)

参数
以下是调用函数时可使用的正式参数类型：

• 必备参数 必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样
• 命名参数 使用关键字参数允许函数调用时参数的顺序与声明时可以不一致，因为 Python 解释器能够用参数名匹配参数值
• 缺省参数 调用函数时，缺省参数的值如果没有传入，则被认为是默认值
• 不定长参数 如果调用的时候的参数比声明的要多情况下，可采用不定长参数 加了星号（*）的变量名会存放所有未命名的变量参数

#!/usr/bin/python
# -*- coding: UTF-8 -*-

def useParamer(name,age=18):
    print('名字:',name,'年龄:',age)

useParamer(name='mike')

def useParamer(name,age):
    print('名字:',name,'年龄:',age)

useParamer(age = '20',name='lina')


def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)
    return

printinfo(10)
printinfo(70, 60, 50)

匿名函数
python 使用 lambda 来创建匿名函数：

• lambda只是一个表达式，函数体比def简单很多
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

lambda函数的语法只包含一个语句：lambda [arg1 [,arg2,.....argn]]:expression

# coding=utf-8
# !/usr/bin/python

# 定义匿名函数
sum = lambda arg1, arg2: arg1 * arg2;

# 调用sum函数
print("Value of total : ", sum(10, 20))
print("Value of total : ", sum(20, 20))

变量和局部变量:

• 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
• 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

# coding=utf-8
# !/usr/bin/python

num = 2

def myfun():
    global num # 函数内部想访问函数外的全局变量需要 加上global关键字
    num = num +1
    print(num)

myfun()

print(num)

Python 模块

简单的讲模块就是个.py后缀的文件，使用模块可以是应用的代码更加的清晰，模块中可以定义变量，函数和类，同时也可以包含可执行代码
import 语句
如果想要在一个python文件中导入另外一个python文件，那么可以采用import语句，解析器搜索路径下的模块就会将其导入，然后就可以在当前模块下直接调用导入模块的函数了
语法：

• import module1[, module2[,... moduleN] 导入模块
• from modname import name1[, name2[, ... nameN]] 导入模块中的指定部分
• from…import* 导入模块中的全部内容

# coding=utf-8
# !/usr/bin/python

import time #导入time模块

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))  # 调用time模块中的函数解决时间业务需求

定位模块
当import导入一个模块时，底层Python解析器对模块位置的搜索顺序是:

• 当前目录
• 如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录
• 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/

模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录

PYTHONPATH变量
作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。

• 在Windows系统，典型的PYTHONPATH：set PYTHONPATH=c:\python20\lib
• 在UNIX系统，典型的PYTHONPATH如下：set PYTHONPATH=/usr/local/lib/python

dir()函数
dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字

# coding=utf-8
# !/usr/bin/python

import time #导入time模块

print(dir())

# OUTPUT ： ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'time']

在这里，特殊字符串变量name指向模块的名字，file指向该模块的导入文件名

globals()和locals()函数

• 根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。
• 如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。
• 如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。
• 两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。

# coding=utf-8
# !/usr/bin/python

num1 = 10

def myfun():
    num2 = 20
    num3 = 30
    sum = num2 + num3

    print('函数里访问的命名',locals())
    print('函数里能访问的全局名',globals())

myfun()

print('函数外调用locals',locals())
print('函数外调用globals',globals())

print(type(locals()))

#输出的是字典类型数据

reload()函数
当一个模块被引入一个执行脚本时，代码只会从上至下执行一次，如果想重新执行模块里顶层部分的代码，可以用reload()函数。该函数会重新导入之前导入过的模块
语法：reload(module_name)

Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境

例子：

image.png

demo01.py 模块

# coding=utf-8
# !/usr/bin/python

import pack

pack.ones() #调用pack包中one模块的ones方法

pack.twos() #调用pack包中two模块的twos方法

pack包下分别有：
one模块( ones()函数 )
two模块( twos()函数 )

# pack目录下创建___init__.py文件模块 使用显式的导入语句
from .one import ones
from .two import twos

这里包的引入模块原理应该是impot引入一个包的时候,会先执行init.py文件，先加载init.py文件中的引入模块，这样在当前的demo.py文件中只需引入pack包就可以直接调用包里面模块的函数

Python 文件I/O

打开和关闭文件
open()函数
open()函数打开一个文件，创建一个文件，然后就可以调用相关的辅助方法才可以调用它进行读写
语法：file object = open(file_name [, access_mode][, buffering])
参数:

• file_name：file_name变量是一个包含了你要访问的文件名称的字符串值
• access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)
• buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认

模式	价格
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file对象的属性

属性	描述
file.closed	返回true如果文件已被关闭，否则返回false。
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#打开文件
fo = open('test.txt')

print(fo.closed)  # 检测文件是否已打开
print(fo.mode)    # 返回文件的模式
print(fo.name)    # 返回文件名
# print(fo.softspace)  python3 没有该属性

file对象的方法
read()方法

• read()方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字
• 语法:fileObject.read([count]);
• 参数:被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#打开文件
fo = open('test.txt','r+')

print(fo.read(12))  # 读取文件

fo.close()       # 关闭文件

Write()方法

• Write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
• Write()方法不在字符串的结尾不添加换行符('\n')
• 语法 fileObject.write(string)

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#打开文件
fo = open('test.txt','a+')

fo.write('骚年加油哦！！！\n')

fo.close()       # 关闭文件

Close()方法

• File对象的close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
  当一个文件对象的引用被重新指定给另一个文件时，Python会关闭之前的文件。用close（）方法关闭文件是一个很好的习惯
• 语法：fileObject.close();

remove()方法

• 可以用remove()方法删除文件，需要提供要删除的文件名作为参数
• 语法：os.remove(file_name)

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os

os.remove("test.txt")  # 删除文件

Python的目录操作
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。os模块有许多方法能帮你创建，删除和更改目录
mkdir()方法

• 可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数
• 语法：os.mkdir("newdir")

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import os

os.mkdir('test.txt')  # 创建一个目录

chdir()方法

• 可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
• 语法：os.chdir("newdir")

rmdir()方法

• rmdir()方法删除目录，目录名称以参数传递。
• 在删除这个目录之前，它的所有内容应该先被清除。
• 语法：os.rmdir('dirname')

Python 异常处理

什么是异常：

• 异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行
• 一般情况下，在Python无法正常处理程序时就会发生一个异常
• 异常是Python对象，表示一个错误
• 当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行

异常处理：

• 捕捉异常可以使用try/except语句
• try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理
• 如果你不想在异常发生时结束你的程序，只需在try里捕获它

try的工作原理：

当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

• 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
• 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
• 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

try:
    int('a')
except:
    print('int()方法,参数需要为数字 要不会报错')
else:
    print('OK')

try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码

python与Java的异常处理模式相似，异常处理语句也可以嵌套
如果外层try子句中的代码引发异常，程序将直接跳转到外层try对应的except子句，而内部的try子句将不会被执行

#!/usr/bin/python
# -*- coding: UTF-8 -*-

try:
     s = "hello"
     try:
          print(s[0] + s[1])
          print(s[0] - s[1])
     except TypeError:
          print("字符串不支持减法运算")
except:
     print("异常")

raise抛出异常 捕捉异常

#!/usr/bin/python
# -*- coding: UTF-8 -*-

num = 2

try:
    if(num > 1):
        raise Exception(num,'大于1')
    elif(num < 1):
        raise Exception(num,'小于1')
    else:
        raise Exception(num,'等于1')
except Exception as e:
        print(e)

Exception 源码

class Exception(BaseException):
    """ Common base class for all non-exit exceptions. """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass