Python学习

[keyfall]

列表和元组

列表和元组的重要区别 列表是[],元组是() 元组是设定好就固定了，列表可以改变(列表就是在python缓存里，取的话更快)

列表的方法 a=[2,2,3,4,56,6] a.apend(0) "在列表最后添加0 a.insert(1,5) "在列表索引位置1的地方添加5 a.remove(2) "删除第一次出现的2(就是删除值不是索引) a[0] "列表索引为0的值(元组也是这么取值) a[3:6] "列表中从索引3到6的值(不包含6) a.index(2) "列表中第一次出现2的索引值 a.count(2) “列表中出现2的次数 a.sort() "正向排序 a.sort(reverse=True) "反向排序

多维列表

b=[[1,2,3], [2,3,4]] b[1][2] "多维列表索引1中的索引2的值也就是4

[keyfall]

字典

字典键值，键是字符串类型，值是任意类型，比如int类型，字符串类型，元组，列表，字典

c={'aaa':1,'bbb':2,'ccc':'ddd'}

c['aaa'] "字典中键为aaa的值

c['xx']="sdfsd" 字典中加上'xx':"sdfsd"这个键值对，如果xx在字典中有，那么就是更改内容

[keyfall]

try except

try: file=open('eee','r') except Exception as e: print("没有文件叫eee") response = input("你想创建么") if response == 'y': file = open('eee','w') else: pase else: file.write("ssss") file.close()

[keyfall]

zip,lambda,map

zip

a=[1,2,3] b=[4,5,6] zip(a,b) "这里是一个文件 list(zip(a,b)) "这里就显示[(1,4),(2,5),(3,6)] 可以这样写 list(zip(a,a,b)) ”这样就是[(1,1,4),(2,2,5),(3,3,6)]

lambda

是让函数写法更简单(暂时只知道这些，后期补充) 比如： def fun1(x,y): return(x+y) fun1函数等同于下面 fun2=lambda x,y:x+y

map

list(map(fun1,[1],[2])) "显示是[3],上面的fun1函数 list(map(fun1,[1,2],[3,4])) "显示是[4,6] list(map(fun1,[1,2],[3])) “如果参数不够，不够的就不算

[keyfall]

浅复制 深复制

a=[1,2,3] b=a b=a代表a和b指向了相同的地方

c=copy.copy(a) 这里a和c的内容一样，但是指向了不同的地方， a指向了一个地址，这个地址内容是[1,2,3] c指向了另一个地址，这个地址内容也是[1,2,3] 但是如果 a=[1,2,3,[4,5]] c=copy.copy(a) 这样的话a[3]和c[3]是指向同一地址 其实a[3]也是指向的另一地址，这个地址指向的是[4,5],c[3]也是指向的这个地址 这就是浅复制，只复制第一层内容到不同地址，如果里面再有地址，就直接复制地址

d=copy.deepcopy(a) 这个就是深复制，复制了所有的内容到不同地址 这个浪费内存，根据情况使用

[keyfall]

python3读写操作

读文件

f=open("222.txt",encoding="utf-8")
data=f.readlines()
print(data)
f.close()

f.readlines()是读取所有的内容 f.readline()是读取一行，如果想看下一行，就再写一行f.readline() f.readable()是判断是否可读

写操作

f=open("222.txt",'w',encoding='utf-8')
f.write("sdfsdf\nsdfsdfsd\nsdfsdfsdf")
f.close()

f.write()中的\n是下一行 也可以这么写 f.writelines(['sdfsdf\n','sdfsdfsdfs\n']) 这样更加容易看

如果222.txt里面有内容，那么就会被新的覆盖掉，可以用追加操作避免

追加操作

f = open("222.txt","a",encoding='utf-8') f.write("sdsssssss")

这是open的参数

[keyfall]

python基础

标识符 在 Python 里，标识符由字母、数字、下划线组成。 在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。 Python 中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。

以双下划线开头的 foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init__() 代表类的构造函数。

多行语句 用/进行一行分多行

total = item_one + \
        item_two + \
        item_three

多个变量赋值

a = b = c = 1
a, b, c = 1, 2, "john"

删除变量 del var1[,var2[,var3[....,varN]]]]

是重复 `var1 = 'sdf' 2 `

[keyfall]

python基础

标识符 在 Python 里，标识符由字母、数字、下划线组成。 在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。 Python 中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。

以双下划线开头的 foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init__() 代表类的构造函数。

多行语句 用/进行一行分多行

total = item_one + \
        item_two + \
        item_three

多个变量赋值

a = b = c = 1
a, b, c = 1, 2, "john"

删除变量 del var1[,var2[,var3[....,varN]]]]

是重复 `var1 = 'sdf' 2 `

// 取整除-向下取接近除数的整数

>>> 9//2
 4 
>>> -9//2 
-5

幂 - 返回x的y次幂(ab a的b次方)

r/R
原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。

print( r'\n' )
print( R'\n' )

字符串以f开头

import time
t0 = time.time()
time.sleep(1)
name = 'processing'

# 以 f开头表示在字符串内支持大括号内的python 变量或表达式
print(f'{name} done in {time.time() - t0:.2f} s') 

>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob' 

#%6.3f表示小数点后面精确到3位，总长度6位数，包括小数点，不够左侧补空格  
print "PI=%6.3f" % math.pi          # output: PI=_3.142  

格式化操作符的辅助指令例子

str.format()

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

[keyfall]

元组中元素不能修改，删除，添加 可以使用del删除整个元组 元组中只包含一个元素时，需要在元素后面添加逗号

>>>tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

删除字典元素

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住 键必须不可变，所以可以用数字，字符串或元组充当,而用列表就不行

显示内存地址 print(id(标识符))

update方法，如果键不一样，就会添加到前面的字典中，键一样，值不一样，值会发生改变

集合（set）是一个无序的不重复元素序列。 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}
或者
set(value)

set.update(x) 添加元素，且参数可以是列表，元组，字典等

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

集合删除元素 s.remove( x ) 删除元素x,不存在报错 s.discard( x ) 删除元素x,不存在不报错 s.pop() 随机删除元素

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，

# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

迭代器有两个基本的方法： iter() 和 next()。

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

yield生成器 next()

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

[keyfall]

python 函数的参数传递：

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

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

不定长参数 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)

# 调用printinfo 函数
printinfo( 70, 60, 50 )

加了两个星号 ** 的参数会以字典的形式导入。

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)

# 调用printinfo 函数
printinfo(1, a=2,b=3)

如果单独出现星号 * 后的参数必须用关键字传入。

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

f(10, 20, 30, d=40, e=50, f=60)

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

读取键盘输入

str = input("请输入：");
print ("你输入的内容是: ", str)

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) file: 必需，文件路径（相对或者绝对路径）。 mode: 可选，文件打开模式 buffering: 设置缓冲 encoding: 一般使用utf8 errors: 报错级别 newline: 区分换行符 closefd: 传入的file参数类型 opener:通过传递可调用对象opener可以使用自定义开启器。然后通过调用opener（文件，标志）获取文件对象的基础文件描述器。opener必须返回一个打开的文件描述器（传递os.open为opener 结果类似的功能 None）。

os方法

[keyfall]

init() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

性能测试

from timeit import timeit

def func():
    s = 0
    for i in range(1000):
        s += i
    print(s)

# timeit(函数名_字符串，运行环境_字符串，number=运行次数)
t = timeit('func()', 'from __main__ import func', number=1000)
print(t)

import profile

def test():
    total=0
    for i in range(500000):
        total +=i

t = profile.run("test()")
print(t)

计算元素在列表中出现的次数

def countX(lst, x): 
    return lst.count(x) 

lst = [8, 6, 8, 10, 8, 20, 10, 8, 8] 
x = 8
print(countX(lst, x)) 

使用递归计算列表元素之和

list1 = [11, 5, 17, 18, 23] 

def sumOfList(list, size): 
   if (size == 0): 
     return 0
   else: 
     return list[size - 1] + sumOfList(list, size - 1) 

total = sumOfList(list1, len(list1)) 

print("列表元素之和为: ", total) 

min方法获取列表最小元素

list1 = [10, 20, 1, 45, 99] 

print("最小元素为:", min(list1)) 

移除字符串中指定位置字符

test_str = "Runoob"
new_str = test_str.replace(test_str[3], "", 1)
print(new_str)

str = 'Runoob'
def ff(str,num):
    return str[:num] + str[num+1:];
print(ff(str,2));
print(ff(str,4));

[keyfall]

join链接list成为字符串

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'

list分割字符串

>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s 
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")   
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1) 
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']

判断元素是否在列表中存在

test_list_bisect = [ 1, 6, 3, 5, 3, 4 ] 
if bisect_left(test_list_bisect, 4): 
    print ("存在") 

test_list = [ 1, 6, 3, 5, 3, 4 ] 
if (4 in test_list): 
    print ("存在") 

将字符串作为代码执行

def exec_code(): 
    LOC = """ 
def factorial(num): 
    fact=1 
    for i in range(1,num+1): 
        fact = fact*i 
    return fact 
print(factorial(5)) 
"""
    exec(LOC) 

exec_code()

字符串翻转

str='Runoob'
print(str[::-1])

str='Runoob'
print(''.join(reversed(str)))

字典按值排序

def dictionairy():  

    # 声明字典
    key_value ={}     

    # 初始化
    key_value[2] = 56       
    key_value[1] = 2 
    key_value[5] = 12 
    key_value[4] = 24
    key_value[6] = 18      
    key_value[3] = 323 

    print ("按值(value)排序:")   
    print(sorted(key_value.items(), key = lambda kv:(kv[1], kv[0])))     

def main(): 
    dictionairy()             

if __name__=="__main__":       
    main()

lis = [{ "name" : "Taobao", "age" : 100},  
{ "name" : "Runoob", "age" : 7 }, 
{ "name" : "Google", "age" : 100 }, 
{ "name" : "Wiki" , "age" : 200 }] 

# 通过 age 升序排序
print ("列表通过 age 升序排序: ")
print (sorted(lis, key = lambda i: i['age']) )

print ("\r") 

# 先按 age 排序，再按 name 排序
print ("列表通过 age 和 name 排序: ")
print (sorted(lis, key = lambda i: (i['age'], i['name'])) )

print ("\r") 

# 按 age 降序排序
print ("列表通过 age 降序排序: ")
print (sorted(lis, key = lambda i: i['age'],reverse=True) )

计算列表元素之和

list1 = [11, 5, 17, 18, 23] 

def sumOfList(list, size): 
   if (size == 0): 
     return 0
   else: 
     return list[size - 1] + sumOfList(list, size - 1) 

total = sumOfList(list1, len(list1)) 

print("列表元素之和为: ", total) 

移除字符串中指定位置字符

test_str = "Runoob"
new_str = test_str.replace(test_str[3], "", 1)
print(new_str)

str = 'Runoob'
def ff(str,num):
    return str[:num] + str[num+1:];
print(ff(str,2));
print(ff(str,4));

[keyfall]

插入排序

从头开始取值，跟前面的值比较大小，比前面值小，就换位，比前面值大，就继续取值。最后完成排序

def insertionSort(arr): 

    for i in range(1, len(arr)): 

        key = arr[i] 

        j = i-1
        while j >=0 and key < arr[j] : 
                arr[j+1] = arr[j] 
                j -= 1
        arr[j+1] = key 

arr = [12, 11, 13, 5, 6] 
insertionSort(arr) 
print ("排序后的数组:") 
for i in range(len(arr)): 
    print ("%d" %arr[i])

快速排序

选定一个 基准值，比基准值小的放左边，比基准值大的放右边，再分别递归这两个子序列

def partition(arr,low,high): 
    i = ( low-1 )         # 最小元素索引
    pivot = arr[high]     

    for j in range(low , high): 

        # 当前元素小于或等于 pivot 
        if   arr[j] <= pivot: 

            i = i+1 
            arr[i],arr[j] = arr[j],arr[i] 

    arr[i+1],arr[high] = arr[high],arr[i+1] 
    return ( i+1 ) 

# arr[] --> 排序数组
# low  --> 起始索引
# high  --> 结束索引

# 快速排序函数
def quickSort(arr,low,high): 
    if low < high: 

        pi = partition(arr,low,high) 

        quickSort(arr, low, pi-1) 
        quickSort(arr, pi+1, high) 

arr = [10, 7, 8, 9, 1, 5] 
n = len(arr) 
quickSort(arr,0,n-1) 
print ("排序后的数组:") 
for i in range(n): 
    print ("%d" %arr[i]),

选择排序

从第一个数开始，跟后面的进行比较，找到最小或最大的数，放到最开头或者最末尾，然后从第二个数开始重复。

A = [64, 25, 12, 22, 11] 

for i in range(len(A)): 

    min_idx = i 
    for j in range(i+1, len(A)): 
        if A[min_idx] > A[j]: 
            min_idx = j 

    A[i], A[min_idx] = A[min_idx], A[i] 

print ("排序后的数组：") 
for i in range(len(A)): 
    print("%d" %A[i]),

[keyfall]

冒泡排序

冒泡排序就是从头开始两个两个比较，后面小的就跟前面换，换到最后，最后就是最大的，然后再从头开始进行两两比较（因为前面小的还没比过呢）

def bubbleSort(arr):
    n = len(arr)

    # 遍历所有数组元素
    for i in range(n):

        # Last i elements are already in place
        for j in range(0, n-i-1):

            if arr[j] > arr[j+1] :
                arr[j], arr[j+1] = arr[j+1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]

bubbleSort(arr)

print ("排序后的数组:")
for i in range(len(arr)):
    print ("%d" %arr[i]),

归并排序 开始2个比较，然后比较好的2个再跟另外两个比较好的比较形成一个新的4个元素数组A，接着按照前面方法，再弄出一个排好的4个元素的数组B，A和B再进行比较，形成一个新的排列好的8个元素数组，以此类推。

[keyfall]

mysql-connector使用

安装

pip install mysql-connector

创建数据库

import mysql.connector

#创建驱动
mydb = mysql.connector.connect(
  host="localhost",       # 数据库主机地址
  user="yourusername",    # 数据库用户名
  passwd="yourpassword"   # 数据库密码
)
#创建浮标，用来执行sql语句
mycursor = mydb.cursor()

# 创建数据库
mycursor.execute("CREATE DATABASE runoob_db")

# 查看所有数据库
mycursor.execute("SHOW DATABASES")

for x in mycursor:
  print(x)

数据表操作

创建数据表之前需要创建数据库

import mysql.connector

mydb = mysql.connector.connect(
  host="localhost",
  user="root",
  passwd="123456",
  #把数据库写在这里，没有数据库报错
  database="runoob_db"
)
mycursor = mydb.cursor()

#创建数据表
mycursor.execute("CREATE TABLE sites (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), url VARCHAR(255))")

#插入数据
sql = "INSERT INTO sites (name, url) VALUES (%s, %s)"
val = ("RUNOOB", "https://www.runoob.com")
mycursor.execute(sql, val)

mydb.commit()    # 数据表内容有更新，必须使用到该语句

print(mycursor.rowcount, "记录插入成功。")

#批量插入
sql = "INSERT INTO sites (name, url) VALUES (%s, %s)"
val = [
  ('Google', 'https://www.google.com'),
  ('Github', 'https://www.github.com'),
  ('Taobao', 'https://www.taobao.com'),
  ('stackoverflow', 'https://www.stackoverflow.com/')
]
#使用executemany(sql,val)
mycursor.executemany(sql, val)

mydb.commit()    # 数据表内容有更新，必须使用到该语句

print(mycursor.rowcount, "记录插入成功。")

#查询数据
mycursor.execute("SELECT * FROM sites")

myresult = mycursor.fetchall()     # fetchall() 获取所有记录
#或者使用下面语句读取一条数据
#myresult = mycursor.fetchone()
for x in myresult:
  print(x)

#指定起始位置offset
mycursor.execute("SELECT * FROM sites LIMIT 3 OFFSET 1")  # 0 为 第一条，1 为第二条，以此类推  

myresult = mycursor.fetchall()

for x in myresult:
  print(x)

#删除表drop table
sql = "DROP TABLE IF EXISTS sites"  # 删除数据表 sites

mycursor.execute(sql)

sql语句尽量使用%s占位符来写，可以防止sql注入攻击

sql = "DELETE FROM sites WHERE name = %s"
na = ("stackoverflow", )

mycursor.execute(sql, na)

最后需要进行cursor关闭和mydb关闭

mycursor.close()
mydb.close()

[keyfall]

pymysql

实例

import pymysql

# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# 使用 execute()  方法执行 SQL 查询 
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()

print ("Database version : %s " % data)

# 关闭数据库连接
db.close()

数据库插入

import pymysql

# 打开数据库连接
db = pymysql.connect("localhost","testuser","test123","TESTDB" )

# 使用cursor()方法获取操作游标 
cursor = db.cursor()

# SQL 插入语句
sql = "INSERT INTO EMPLOYEE(FIRST_NAME, \
       LAST_NAME, AGE, SEX, INCOME) \
       VALUES ('%s', '%s',  %s,  '%s',  %s)" % \
       ('Mac', 'Mohan', 20, 'M', 2000)
try:
   # 执行sql语句
   cursor.execute(sql)
   # 执行sql语句
   db.commit()
except:
   # 发生错误时回滚
   db.rollback()

# 关闭数据库连接
db.close()

这里发生错误的时候，执行rollback()，回滚事务，就是当前游标的操作都回滚了.

修改删除都跟插入差不多，就是sql语句不同

[keyfall]

网络编程socket

Python3 网络编程 python3 socket编程 []()

[keyfall]

smtp

smtp发送邮件 讲的挺详细的，下面的例子是个正文发送文本的模板，上面的链接里讲的挺多功能，有发送html,发送附件，发送带图片的html，跟模板主要区别就是在message的不同。

例子

import smtplib
from email.mime.text import MIMEText
from email.header import Header

sender = '发送人邮件地址'
receivers = ['接收人邮件地址']  # 接收邮件，可设置为你的QQ邮箱或者其他邮箱

# 三个参数：第一个为文本内容，第二个 plain 设置文本格式，第三个 utf-8 设置编码
message = MIMEText('Python 邮件发送测试...', 'plain', 'utf-8')

message['From'] = Header("菜鸟教程", 'utf-8')  # 发送者
message['To'] = Header("测试", 'utf-8')  # 接收者

subject = 'Python SMTP 邮件测试'
message['Subject'] = Header(subject, 'utf-8')

try:
    smtpObj = smtplib.SMTP('smtp.qq.com')  #这里使用qq，其他的邮件都不一样，改qq的位置
    smtpObj.login(sender,"smtp密码") #这密码是邮件开启smtp功能时给的
    smtpObj.sendmail(sender, receivers, message.as_string())
    print("邮件发送成功")
except smtplib.SMTPException:
    print("Error: 无法发送邮件")

这里需要开启smtp，在邮箱-设置，账户中 进行验证后会出现密码，密码放在“smtp密码“处

[keyfall]

多线程

python3多线程 thread.join()方法就是现在就是运行thread这个线程，这个线程执行完毕，再执行其他的 线程的先进先出，后进先出，优先级队列

[keyfall]

xml用来传输数据的

XML语法规则

XML 文档必须有根元素 所有的 XML 元素都必须有一个关闭标签 XML 标签对大小写敏感 XML 属性值必须加引号

在 XML 中，多个空格会被保留，不会合并为一个空格

使用css显示xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/css" href="cd_catalog.css"?>
<CATALOG>
<CD>
<TITLE>Empire Burlesque</TITLE>
<ARTIST>Bob Dylan</ARTIST>
<COUNTRY>USA</COUNTRY>
<COMPANY>Columbia</COMPANY>
<PRICE>10.90</PRICE>
<YEAR>1985</YEAR>
</CD>
<CD>
<TITLE>Hide your heart</TITLE>
<ARTIST>Bonnie Tyler</ARTIST>
<COUNTRY>UK</COUNTRY>
<COMPANY>CBS Records</COMPANY>
<PRICE>9.90</PRICE>
<YEAR>1988</YEAR>
</CD>
.
.
.
</CATALOG>

解析xml文档

<html>
<body>
<h1>W3Schools Internal Note</h1>
<div>
<b>To:</b> <span id="to"></span><br />
<b>From:</b> <span id="from"></span><br />
<b>Message:</b> <span id="message"></span>
</div>

<script>
if (window.XMLHttpRequest)
{// code for IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
}
else
{// code for IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.open("GET","note.xml",false);
xmlhttp.send();
xmlDoc=xmlhttp.responseXML;

document.getElementById("to").innerHTML=
xmlDoc.getElementsByTagName("to")[0].childNodes[0].nodeValue;
document.getElementById("from").innerHTML=
xmlDoc.getElementsByTagName("from")[0].childNodes[0].nodeValue;
document.getElementById("message").innerHTML=
xmlDoc.getElementsByTagName("body")[0].childNodes[0].nodeValue;
</script>

</body>
</html>

解析xml字符串

<html>
<body>
<h1>W3Schools Internal Note</h1>
<div>
<b>To:</b> <span id="to"></span><br />
<b>From:</b> <span id="from"></span><br />
<b>Message:</b> <span id="message"></span>
</div>

<script>
txt="<note>";
txt=txt+"<to>Tove</to>";
txt=txt+"<from>Jani</from>";
txt=txt+"<heading>Reminder</heading>";
txt=txt+"<body>Don't forget me this weekend!</body>";
txt=txt+"</note>";

if (window.DOMParser)
{
parser=new DOMParser();
xmlDoc=parser.parseFromString(txt,"text/xml");
}
else // Internet Explorer
{
xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
xmlDoc.async=false;
xmlDoc.loadXML(txt);
}

document.getElementById("to").innerHTML=
xmlDoc.getElementsByTagName("to")[0].childNodes[0].nodeValue;
document.getElementById("from").innerHTML=
xmlDoc.getElementsByTagName("from")[0].childNodes[0].nodeValue;
document.getElementById("message").innerHTML=
xmlDoc.getElementsByTagName("body")[0].childNodes[0].nodeValue;
</script>
</body>
</html>

[keyfall]

python3 xml解析

python3 xml解析 虽然说给的属性和方法不太全，基本功能有了，例子也有。

json数据解析

json.dumps(): 对数据进行编码。 json.loads(): 对数据进行解码。

python和json类型转换

实例

import json

# Python 字典类型转换为 JSON 对象
data1 = {
    'no' : 1,
    'name' : 'Runoob',
    'url' : 'http://www.runoob.com'
}

json_str = json.dumps(data1)
print ("Python 原始数据：", repr(data1))
print ("JSON 对象：", json_str)

# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
print ("data2['name']: ", data2['name'])
print ("data2['url']: ", data2['url'])

结果

Python 原始数据： {'name': 'Runoob', 'no': 1, 'url': 'http://www.runoob.com'}
JSON 对象： {"name": "Runoob", "no": 1, "url": "http://www.runoob.com"}
data2['name']:  Runoob
data2['url']:  http://www.runoob.com

处理文件实例

# 写入 JSON 数据
with open('data.json', 'w') as f:
    json.dump(data, f)

# 读取数据
with open('data.json', 'r') as f:
    data = json.load(f)

[keyfall]

日期和时间

获取格式化时间

import time

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

time.time()获取当前时间戳 localtime()时间戳换成时间元组

time.strftime()格式化时间

import time

# 格式化成2016-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))

获取日历

import calendar

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

time模块和calendar模块方法和解释例子

[keyfall]

内置函数

忘了直接查

compile函数 当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。

zip函数 将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

round函数 round(2.675, 2) 这个会显示2.67，不是2.68，我们知道在机器中浮点数不一定能精确表达，因为换算成一串 1 和 0 后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离 2.67 要更近一点点，所以保留两位小数时就近似到了 2.67。

[keyfall]

mongodb pymongo