python之基础相关

1.python基础知识

1.1.条件语句

if num == 3 and num == 4:
	print("boss")
elif num == 2 or num == 5:
	print("user")

1.2.循环语句

# while循环语句
while a < 10:
	print(a)
	a += 2

# for循环语句
#直接访问元素：
for letter in "python":
	print(letter)
#访问索引
fruits = ["banana","apple","mango"]
for index in range(len(fruits)):
	print(fruits[index])

#循环使用 else 语句
#在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print '%d 等于 %d * %d' % (num,i,j)
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print num, '是一个质数'

1.3.pass语句

pass不作任何事情，一般用于做占位语句

if true:
	pass

1.4.数字类型相关

Python Number 类型转换

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

Python math 模块、cmath 模块
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
1.python数学函数

abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

2.python随机数函数

choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

3.python三角函数

acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

1.5.字符串

1.5.1.字符串格式化

1.5.2.python访问字符串中的值

var = "Hello World"
print(var[0])
print(var[1:5])

1.5.3.python字符串运算符

+	字符串连接	
>>>a + b
'HelloPython'
*	重复输出字符串	
>>>a * 2
'HelloHello'
[]	通过索引获取字符串中字符	
>>>a[1]
'e'
[ : ]	截取字符串中的一部分	
>>>a[1:4]
'ell'
in	成员运算符 - 如果字符串中包含给定的字符返回 True	
>>>"H" in a
True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	
>>>"M" not in a
True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	
>>>print r'\n'
\n
>>> print R'\n'
\n
%	格式字符串	请看下一章节

1.5.4.python三引号

Python 中三引号可以将复杂的字符串进行赋值。

Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）

 >>> hi = '''hi 
there'''

1.5.5.Unicode字符串

>>> u'Hello World !'
u'Hello World !'

1.6.列表

# 创建
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
# 访问
list1[0]
# 修改
list1[1] = 'what'
# 删除
del list1

Python列表脚本操作符

Python列表函数&list类方法

1.7.元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。

# 创建元组
tup1 = ('physics', 'chemistry', 1997, 2000)
tup1 = ()
# 元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,)

1.8.字典

>>> dict = {'a': 1, 'b': 2, 'b': '3'}
>>> dict['b']
'3'
>>> dict
{'a': 1, 'b': '3'}

字典内置函数%方法：

1.9.python日期与时间

import time  # 引入time模块
ticks = time.time()
print "当前时间戳为:", ticks
#输出结果为：
当前时间戳为: 1459994552.51

什么是时间元组？
很多Python函数用一个元组装起来的9组数字处理时间:

上述也就是struct_time元组。这种结构具有如下属性：

获取当前时间

import time
localtime = time.localtime(time.time())
print "本地时间为 :", localtime
#输出2

获取格式化的时间

localtime = time.asctime( time.localtime(time.time()) )
print("本地时间为 :"localtime)

1.10.python函数

语法：

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

关键字参数顺序不重要

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return
#调用printinfo函数
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 )

默认函数

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

1.11.python模块

from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
from modname import name1[, name2[, … nameN]]
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
from fib import fibonacci
运行

if __name__ == '__main__':
    print '作为主程序运行'
else:
    print 'package_runoob 初始化'

1.12.异常处理

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

2.python面向对象

2.1.类

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

2.2.python内置类属性

dict : 类的属性（包含一个字典，由类的数据属性组成）
doc :类的文档字符串
name: 类名
module: 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
bases : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

2.3.类的继承

class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"
 
   def parentMethod(self):
      print '调用父类方法'
 
   def setAttr(self, attr):
      Parent.parentAttr = attr
 
   def getAttr(self):
      print "父类属性 :", Parent.parentAttr
 
class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"
 
   def childMethod(self):
      print '调用子类方法'
 
c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法 - 设置属性值
c.getAttr()          # 再次调用父类的方法 - 获取属性值

2.4.基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写：

2.5.类属性与方法

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
单下划线是protected变量
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
继承：class DerivedClassName（BaseClassName）pass就是尚未定义，跟父类一样
子类的构造函数中需要先调用super().init()

3.python正则表达式（.*?表示非贪婪匹配，爬虫常用）

3.1.re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
函数语法：
re.match(pattern, string, flags=0)
函数参数说明:

匹配成功re.match方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
   print "matchObj.group() : ", matchObj.group()
   print "matchObj.group(1) : ", matchObj.group(1)
   print "matchObj.group(2) : ", matchObj.group(2)
else:
   print "No match!!"


# 结果如下：
matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

3.2.re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)

3.3.检索和替换

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：

• pattern : 正则中的模式字符串。
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import re
# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

3.4.re.compile函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
语法格式为：
re.compile(pattern[, flags])

>>>import re
>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

3.5.findall函数

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
findall(string[, pos[, endpos]])

3.6.分隔字符串

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])

4.其他相关技巧

4.1.zip(a,b)

1、 zip（a，b）将两个列表的对应索引打包成一个列表，每个元素都是一个元组。

4.2.收集参数

在函数参数前加*，相当于往函数中传入若干个参数后将他们组合成一个列表的形式传入参数

def mylack(*arg):
    for x in arg:
        print(x)

mylack("a","b","c")

4.3.全局参数

Python是没有引用和指针作为参数的，想在函数内部修改全局变量的值必须先用global关键字声明在赋值
如
global count
count=50

4.4.filter内置函数

用于过滤一个列表中的0和false
高级运用：

4.5.查看内存地址

id(变量）

4.6.pickle模块

通过二进制字节流读取和存储pkl文件（主要用于存取数据，如列表字典等）

4.7.with的妙用

with open(‘data.txt’) as f,这样python编译器会关注文件对象，如果没有用到会自动调用close（）函数

5.python文件操作

5.1.文件路径

# 获得文件绝对路径
filepath = os.path.realpath(__file__)
# 获得文件目录绝对路径
dirpath = os.path.dirname(filepath)
# 获得文件的路径
os.path.getsize(filepath)
# 获得文件的创建/访问/修改时间，返回的是时间戳
os.path.getctime(filepath)
os.path.getatime(filepath)
os.path.getmtime(filepath)
# 判断文件夹还是文件
os.path.isdir(filepath)
# 返回指定文件夹的所有文件名称
lstDir = os.listdir(文件夹的绝对路径) # 如果不加参数默认是工程文件夹

5.2.对文件夹的深度遍历

5.3.文件夹的创建与删除

# 判断文件夹是否存在
if not os.path.exists(文件夹名)
	#创建一个文件夹
	mkdir(文件夹名)

# 删除文件
os.mkdir(文件夹名)

5.4.实例演示

import os
import time
from os.path import join,getsize

def TimeStampToTime(timestamp):
    timeStruct = time.localtime(timestamp)
    return time.strftime("%Y-%m-%d %H:%M:%S",timeStruct)

def calcFileSize(absolutePtah):
    print("开始计算文件大小...")
    return os.path.getsize(absolutePtah)

def calcDirSize(absolutePath):
    # 获取文件的大小
    filesize = os.path.getsize(absolutePath)
    # 使用os.walk()深度遍历文件夹中的文件
    size = 0 #累加子文件大小
    for root,dirs,files in os.walk(absolutePath):
        # 输出遍历文件
        print("|-文件夹路径 %S" % root)
        print("| |-路径下的文件夹: {0}".format(dirs))
        print("| | |-文件夹中的文件: {0}".format(files))
        # 使用summ函数
        size += sum([getsize(os.path.join(root,name)) for name in files])
    return size
def fileDetails(filepath):
    os.system("cls")
    absolutePath = os.path.realpath(filepath)
    fileType = "文件夹" if os.path.isdir(absolutePath) else "文件"
    try:
        size = calcDirSize(absolutePath) \
                if fileType == "文件夹" \
                else calcFileSize(absolutePath)
    except FileNotFoundError:
        print("您输入的文件或文件夹路径有误，请核实后再输入")
        os._exit(0)
    fileName = os.path.basename(absolutePath)
    dirPath = os.path.dirname(absolutePath)
    print("\n------------文件信息-------------")
    print("对象名称:{0}".format(fileName))
    print("所在目录:{0}".format(dirPath))
    print("文件类型:{0}".format(fileType))
    print("对象的大小:{0}".format(size))
    ct = os.path.getctime(absolutePath)
    print("对象创建时间:{0}".format(TimeStampToTime(ct)))
    at = os.path.getatime(absolutePath)
    print("对象访问时间:{0}".format(TimeStampToTime(at)))
    mt = os.path.getmtime(absolutePath)
    print("对象修改时间:{0}".format(TimeStampToTime(mt)))

def main():
    filepath = input("请输入文件路径:")
    fileDetails(filepath)

if __name__ == "__main__":
    main()

5.5.文件IO操作

5.5.1.数据序列化操作

实例：

import pickle
import os
# 员工类
class Employee():
    def __init__(self,empno,ename):
        self.__empno = empno
        self.__ename = ename
        pass
    def __str__(self):
        print("empno:{0}".format(self.__empno))
        print("ename:{0}".format(self.__ename))
        return " "
# 员工操作类
class EmployeeDao():
    def __init__(self):
        pass
    def addEmplouee(self,employee,filePath):
        with open(filePath,"wb") as fp:
            pickle.dump(employee,fp)
            print("添加成功")
            pass
    def findAllEmployee(self,filePath):
        with open(filePath,"rb") as fp:
            data = pickle.load(fp)
            print(data)

if __name__ == "__main__":
    filePath = os.path.join(os.getcwd(),"xxoo")
    print("#"*30)
    print("添加员工信息")
    print("#" * 30)
    empno = input("empno:")
    ename = input("ename:")
    emp = Employee(empno,ename)
    empDao = EmployeeDao()
    empDao.addEmplouee(emp,filePath + os.sep + "employee.info")
    empDao.findAllEmployee(filePath+os.sep+"employee.info")
    pass

5.5.2.JSON存储

5.5.3.CSV存储

6.python多线程

6.1.函数实现多线程

import _thread
import time
# 定义一个线程函数
def wordThread(threadName,delay):
    print("[启动]>>>{0}".format(threadName))
    counter = 0
    for i in range(delay):
        print('{0}正在执行第{1}个线程'.format(threadName,counter))
        counter += 1
        time.sleep(1)
    print("停止运行{0}".format(threadName))

# 主程序入口
if __name__ == "__main__":
    _thread.start_new_thread(wordThread,("thread-1",3))
    _thread.start_new_thread(wordThread, ("thread-2", 2))
    for i in range(4):
        print("主线程正在执行")
        time.sleep(1)
    print("停止运行主线程")

6.2.模块实现多线程

import threading
import time

threads = []
exitflag = 0
def outputtime(threadName,delay,counter):
    while counter:
        if exitflag:
            threading.Thread.exit()
        time.sleep(delay)
        print("{0}{1}".format(threadName,time.ctime(time.time())))
        counter -= 1

class MyThread(threading.Thread):
    def __init__(self,threadID,name,counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter

    def run(self):
        print("启动{0}".format(self.name))
        outputtime(self.name,self.counter,4)

if __name__ == "__main__":
    print("主程序启动")
    thread1 = MyThread(1,"thread-1",4)
    thread2 = MyThread(2,"thread-2",5)
    thread1.start()
    thread2.start()
    threads.append(thread1)
    threads.append(thread1)
    for t in threads
    	t.join()
    print("主线程结束")

6.3.线程同步介绍

6.3.1.锁同步

6.3.2.条件变量同步

生产者消费者模式：

import threading
import time
import random

# 使用共享区模拟变量
count = 0
capacity = 10
# 创建条件对象
condition = threading.Condition()
#生产者线程类
class Producer(threading.Thread):
    def __init__(self,threadName):
        threading.Thread.__init__(self)
        self.threadName = threadName
    def run(self):
        global count
        while True:
            # 使用条件对象获取锁并锁定
            if condition.acquire():
                # 判断共享遍历是否已经达到上限
                if count >= 10:
                    print("共享区已满，生产者进入阻塞状态！")
                    condition.wait()
                else:
                    count += 1
                    msg = time.ctime() + '' + self.threadName + "生产了1件商品放入共享区，共享区总计商品个数:{0}".format(count)
                    print(msg)
                    condition.notify() #唤醒其他阻塞状态的线程
                condition.release() #解除锁定
                time.sleep(random.randrange(10)/5) #随机休眠n秒

#消费者者线程类
class Customer(threading.Thread):
    def __init__(self,threadName):
        threading.Thread.__init__(self)
        self.threadName = threadName
    def run(self):
        global count
        while True:
            # 使用条件对象获取锁并锁定
            if condition.acquire():
                # 判断共享变量是否为空
                if count <= 0:
                    print("共享区为空，消费者进入阻塞状态！")
                    condition.wait()
                else:
                    count -= 1
                    msg = time.ctime()+''+self.threadName+"消费了1件商品放入共享区，共享区总计商品个数:{0}".format(count)
                    print(msg)
                    condition.notify() #唤醒其他阻塞状态的线程
                condition.release() #解除锁定
                time.sleep(random.randrange(10)/5) #随机休眠n秒

if __name__ == "__main__":
    for i in range(2):
        p = Producer('[生产者'+str(i+1)+']')
        p.start()
    for i in range(5):
        p = Customer('[消费者'+str(i+1)+']')
        p.start()

7.python与mysql

7.1.数据库的连接操作

import pymysql

dbserverID = "localhost"
user = "root"
passord = "19990729"
dbname = "houserentals"

try:
    con = pymysql.connect(dbserverID,user,passord,dbname) #数据库连接
except pymysql.err.OperationalError as err:
    print("数据库IP地址或账号密码错误,请核实...")
except pymysql.err.InternalError as err:
    print("数据库没有找到，请核实...")
finally:
    con.close()
    print("关闭数据连接")

7.2.实现数据库添加、修改、删除和查询