python基础

python是动态类型语言，变量类型可变

增强的格式化字符串函数format
”苹果花费为：{};葡萄花费为：{}“.format(apple_cost, group_cost)

round(100/3，4) 小数点后保留4位有效数字

转义字符\

init.py

简化模块导入，__init__.py 在包被导入时会被执行
可以在__init__.py 指定默认需要导入的模块，执行import时，当前目录是不会变的（就算是执行子目录的文件），还是需要完整的包名。
可在__init__.py中对导入的功能或子模块重新命名
__init__.py中__all__变量控制当前包目录包含的内容

python 文件路径

reference
方法一：加入__init__.py

import sys
sys.path.append("..")

方法2：

import os

print '***获取当前目录***'
print os.getcwd()
print os.path.abspath(os.path.dirname(__file__))

print '***获取上级目录***'
print os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
print os.path.abspath(os.path.dirname(os.getcwd()))
print os.path.abspath(os.path.join(os.getcwd(), ".."))

print '***获取上上级目录***'
print os.path.abspath(os.path.join(os.getcwd(), "../.."))

json python

import json
json_info = json.dumps({"a":12})	# 将字典转化为字符串（易于传输）（序列化）
dict1 = json.loads(json_info)		# 将字符串转化为字典（反序列化）

## json.dump()函数的使用，将json信息写进文件，易于存储（序列化）
file = open('1.json','w',encoding='utf-8')
json.dump(json_info,file)
## # json.load()函数的使用，将读取json文件信息，（反序列化）
file = open('1.json','r',encoding='utf-8')
info = json.load(file)

数据类型

字符串str
数字int，float，complex
列表list
元组tuple
字典dict

乘方

import math
math.pow(3,10)
3**10

数学函数

向下取整
math.floor(2.222345) = 2
向上取整
math.ceil(2.333456565) = 3
度的转换
math.radians(180) = 3.1415926....
math.sin
math.pi
max(3,5,7,8)
min(1,2,3)
sum(1,4,5,6)
divmod(10,3) = 3,1(商，余数)

字符串：

line1 ="sdes"   line2 = "asqwdq"
line1 + line2 = "sdesasqwdq"
line2*3 = "asqwdqasqwdqasqwdq"
字符串是不可变类型的变量（改变时，改的是地址指向，原来地址中值并未改变）
line = "ndiefghejhebttttygfhnynynnsss"
line[1:6] = "diefgh"
line[0:20:2] = "nifhjebttghyyns"(取前20个字符并每两个字符取一个)
取后十个字符
line[-10:]
翻转字符
line[::-1]

列表：

可以容纳任意类型任意数量的对象，是可变类型的
val = [ ]
val = list()
val.append(1)
val.append(0, 100)在0处插入100
val.pop(0)删除第0个元素
val.remove(1)移除第一个值为1的元素
val[0] = 10
列表也支持+，即val+[1,2,3,4] = [10,1,2,3,4]
val * 4 = [1,10, 1, 10, 1, 10, 1, 10]
val.append(4)
val[:2] = [1, 10]
val[-2:] = [10,4]
val =  [1,2]
val1 = [3,4]
val+val1 = [1,2,3,4]（不改变val的值）
val.extend(val1) = [1,2,3,4]   (改变了val的值)
a.sort()升序
a.sort(reverse=true)降序
复制
new_val = val（指向同一地址）
new_val1 = val.copy()（两个不同变量）
注意浅拷贝和深拷贝
如val = [1,2,3,4,5,[1,2]]
	val1 = val.copy()
	val1[0] = 9
	print：val = [1,2,3,4,5,[1,2]], val1 = [9,2,3,4,5,[1,2]]
	val[-1] = [3,4]
	print:  val = [1,2,3,4,5,[1,2]], val1 = [9,2,3,4,5,[3,4]]
	val[-1][0] = 999
	print:  val = [1,2,3,4,5,[1,2]], val1 = [9,2,3,4,5,[999,4]]

元组

val = tuple()
val = ()
val.count(1)计算元组中1 的个数
val.index（1）得到1的索引

字典类型

val = dict()
val = {}
val = {'中'：11，‘左’：33}
-->val ['中'] = 11
拉锁函数zip
words = ['中'，‘左’]
loc = [1,2]
new_val = list(zip(words, loc))--> {('中'：1)，(‘左’：2)}（也可连接很多个列表）
dict(newval) = {'中'：1，‘左’：2}

students = ['q', 'b', 'c', 'd']
money = dict.fromkeys(students, 10)（整体初始化为同一值）

访问
money['a']需先存在
money.get('www')（若不存在，则返回None）
money.get('ww', 100)(若不存在，也可返回指定值，但不添加进字典)
money.keys()
money.values()
money.items()
money.pop（‘b’）删除某一个

序列：
列表是容器型序列，字符串是扁平型序列

条件判断

if condition
	do sth
elif
	do sth
else
	do sth

断言（多用于调试）

assert
age = 0
assert age == 1，‘竟然不是1’
如果age ！= 1 会出现崩溃，并输出此字符串

循环

costs = [1,2,3,4,5]
for cost in costs:
	print ("花费{}".format(cost))

import random
rand_numbers = [ ]
while(len(rand_numbers) < 20){
	rand_numbers.append(random.randint(1,10))

for i in range(20)
	print "xxxx"

当循环条件跟数量没有关系的时候，只能用while循环

a = [1,2,3]
b = 1
c = (b in a)---------->返回的是一个布尔型变量
一个元素的元组
b = (1, )

continue 跳过，跳过当前一层循环
break 终止循环

for循环中的else，只要循环中没有碰到任一break，则进入else

for循环可以构建推导式（可以在里面加入if判断）

rand_numbers = list(range(20))
new_numbers = [ ]
for number in rand_numbers:
	new_numbers.append(numbers*10)

列表推导式
new_numbers = [nember*10 for number in rand_numbers]
字典推导式
dict_num = { number : 'A' for number in ran_numbers if number == 10}
元组推导式
tuple_num =(nember*10 for number in rand_numbers)
tuple(tuple_num)---------->注意生成器问题

函数

可以返回多个值，返回一个元组。
函数执行完毕也没有return语句时，自动return None。
函数默认参数必须指向不变对象！（如None，[ ]是可变对象）
位置参数
关键字参数（可不按定义顺序排列）
def test(var）：
var = 100
return var
不建议在函数内部对可变类型进行更改，建议用函数返回值进行重新赋值

参数的收集
def test(var, name, *args, ** kwargs) #*args为位置参数，**kwargs为关键字参数

可以把函数赋值给一个变量

def test()
	print test
c = test
c.__name__--->test
调用时：c()

函数可以当做函数返回值进行返回

def test(func):
	return func
def func():
	print ('func run')
f = test(func)
f.__name__------>func
调用时：f（）

装饰器
装饰器是一个返回函数的高阶函数。

def test():
	return random.random()
def decorator(func):
	def wrapper(*args, **kwargs):
		return func(*args, **kwargs)
	return wrapper
f = decorator(test)----------->等价于装饰器@
f.__name__ ----->wrapper
f()
test.__name__ --------->wrapper

@decorator
def test():
	return random.random()
@decorator
def test2():
	return random.random()*3
def decorator(func):
	def wrapper(*args, **kwargs):
		#do sth
		return rounnd(func(*args, **kwargs), 3)
	return wrapper
test.__name__ --------->wrapper

test()
test2()

类

class person:
	def __init__(self, name, age):   ##模板函数
		self._name = name   ##self后面的是实例化对象的属性，加下划线是代表这个属性是私有的，不应该随意访问
		self._age = age
	def get_name(self):
		return self._name
	def set_name(self, newname):
		self._name = newname
	@property    #此时可以直接用p.age访问，而不是p.get_age()
	def age(self):
		return self._age
		
p = person("wang", 12)

继承
class student(person):
#pass ##pass代表什么都不做，只是占个位
def set_score(self, score):
return self._score = score
def get_score(self):
return self._score
s = student(“aaa”, 12)
s.set_score(11)
s.get_score()

一个python可视化网址http://www.pythontutor.com/

数据库

MySQL数据库基本操作
命令行
连接数据库
mysql -u root -p(u是用户名，p是密码)
/usr/local/MySQL/bin/mysql -u root -p
若忘记密码：
https://blog.csdn.net/Youyou_0826/article/details/78007192

查看数据库
show databases;
选择数据库
use database_name;
show tables;#查看数据库中表格
desc table_name;#查看数据库中某表格的结构
select * from table_name;#查看表格数据
select * from table_name limit 10;#查看表格中前十个数据
creat table '  '{
	' id' int（11） not null auto_increment, 
	'name' varchar not null,
	primery key ('id')
insert into table_name ('id','name ') values(3, 'ssssd');
update 'class' set 'name' = 'dddd' where name  = 'ssssd'
delete from 'class' where name  = 'ssssd'

数据库管理工具
sequelpro: http://www.sequelpro.com/

import json
data = '{"a":1, "b":2, "c":3, "d":4}'
j_data = json.loads(data)
type(json)
with open('/Users/whyan/Desktop/data.json', 'r') as f:
	json.load(f)

python 安装第三方库
pip ；例：pip install pymysql
conda ;例：conda install pymysql

python 操作数据库

import MySQLdb
DATABASE = {
	’host‘ ： '127.0.0.1',#如果是远程数据库，此处为远程服务器ip地址,
	’database’ : 'Examination',
	'user' : 'root',
	'passward' : 'passwsss'
	'charset': 'utf8mb4'	#确定编码格式
}
db = MySQLdb.connect(host = 'localhost', user = 'root', passward = 'passwsss', db = 'Examination')
db = MySQLdb.connect('localhost', 'root',  'passwsss', 'Examination')
db = MySQLdb.connect(**DATABASE)
#以上三种写法等价

游标
查询

cursor = db.cursor()
sql = "select * from class"
cursor.execute(sql)
results = cursor.fetchall()
for row in results:
	print row

插入，删除，更新

cursor = db.cursor()
sql = "insert into table_name ('id','name ') values(3, 'ssssd')"
cursor.execute(sql)
db.commit()

捕捉异常

try:
	do sth
except Exception as e:
	print e
except TypeError as t:
	print t

爬虫

requests 用来获取页面内容
BeautifulSoup 用来提取页面

BeautifulSoup中文文档https://beautifulsoup.readthedocs.io/zh_CN/v4.4.0/
https://www.crummy.com/software/BeautifulSoup/bs3/documentation.zh.html

pip install bs4

import requests
from bs4 import BeautifulSoup
url = 'https://bj.lianjia.com/zufang/'
response  = requests.get(url)
response    #------------>200代表获取到
response.text
#request.post()

soup = BeautifulSoup(response.text, 'lxml')
links_div = soup.find_all('div', class_ = 'content__list--item')
links = [div.a.get('href') for div in links_div]
links_div[1].a.get('href')

优化封装函数:

def get_page(url)
	response  = requests.get(url)
	soup = BeautifulSoup(response.text, 'lxml'）
	return soup
def get_links(url):
	soup = get_page(url)
	links_div = soup.find_all('div', class_ = 'content__list--item')
	links = [div.a.get('href') for div in links_div]
	return links

house_url ='https://bj.lianjia.com/zufang/BJ2541835005718970368.html'
soup = get_page(house_url)
price = soup.find('span', class_='content__aside--title').text
price.strip()   #切除数组前后空格

迭代器
两个基本的方法：iter() 和 next()。迭代器只能往前不会后退。

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

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")


import sys         # 引入 sys 模块
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

#创建迭代器
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x 
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))

迭代器
使用了 yield 的函数被称为生成器（generator）。生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 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()