Python编程快速入门

2020-02-11

最近复习一下Python,做一些简单记录

Python的简单介绍

Python介绍

Python是一种跨平台的计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越多被用于独立的、大型项目的开发。

语言特点

编程语言这么多，我们为什么要学习Python？

语法简洁
跨平台
可扩展
开放源码
类库丰富

发展历史

1990年Python诞生
2000年Python2.0发布
2008年Python3.0发布
2010年Python2.7发布，这也是最后一个Python2.x版本

我们在此直接学习Python3.x版本

环境安装

python安装

https://www.python.org/downloads/

Pycharm安装

https://www.jetbrains.com/pycharm/download/

Python编程利器

python官方文档
iPython
jupyter notebook
sublime text/VSCode
Pycharm
pip

Python 语法介绍

Python以缩进实现语法规范

Hello world

首先以Hello world开始我们的Python学习过程

1	print("Hello world")

输出函数

Python最常用print函数进行输出

1	print("I like Python!")

输入函数

Python最常用input()函数进行输入,但注意所有默认输入类型均为字符串类型,可利用强制类型转换实现所需要的类型输入

a=input()

Python注释

Python注释以#号开始，#后的语句不执行,常用于程序介绍

1	#这是一条Python注释

导入模块

导入已经实现的可以直接使用的模块

1	import time

基础数据类型

整数(int)
浮点数(float)
字符串(str)
布尔值(bool)

可用过type()函数来查看数据类型

print(type(8))
print(type('8'))
print(type(8.0))
print((type(True))

强制类型转换

Python可通过相应的类型函数进行类型转换

1 2	int(8.0) #将浮点型转换为整型 str(123) #将整型转换为字符型

变量的定义与赋值

Python可以直接进行变量定义，无须变量类型说明，可以直接使用=为变量命名

1
2
3

a=8
b="hello"
c=True

变量命名规则

推荐驼峰命名法

基本运算

Python支持常见的数据运算，如加减乘除等，可直接进行变量间的运算

3+2  #加法运算，结果为5
3-2  #减法运算，结果为1
3*2  #乘法运算，结果为6
3/2  #除法运算，结果为1.5
3//2 #除法取整运算，结果为1
3**2 #乘法运算，结果为9
3%2  #取余运算，结果为1

序列数据类型

字符串

字符串是最常用的数据类型，常用单引号和双引号标识，按需决定用单引号还是使用双引号，字符串可根据下标进行索引或切片

1	s="我是一个字符串"

字符串常用操作

字符串有很强大的函数支持，这里只列举最常用的功能，其它的不再一一列举，有需要查询文档即可

成员关系操作符

in 和 not in 常用来判断成员关系

a="123"

'1' in a   #结果为True
'4' in a   #结果为False

连接操作符

+ 常用来进行字符串的连接

1
2
3

a="123"
b="456"
a+b  #结果为123456

重复操作符

*常用来进行字符串的重复

1 2	a="123" a*3 #结果为"123123123"

切片操作符

[:]常用来进行切片操作

a="12345"
a[1:3]  #结果为23
a[:3]   #结果为123
a[-3:]  #结果为345

列表

列表也是很常用的数据结果，以方括号进行标识

1	a=[1,2,3,4,5]

列表常用操作

这里只列举最基本的添加与删除用法，其他的自行查询即可

添加元素

1 2	a=[1,2,3,4,5] a.append(6) #结果为1，2，3，4，5，6

删除元素

1 2	a=[1,2,3,4,5] a.remove(3) #结果为1，2，4，5

元组

其实元组不太常用，我一般会用列表代替，元组以圆括号标识，注意元组的元素不可更改

1 2	a=(1,2,3) b=('a','b','c')

顺序语句

上述所说的一条条的从上到下的属于顺序语句

1
2
3

a=1
b=2
c=3

条件语句

Python使用if elif else 来进行条件语句的标识

a=2
if a==1:
    print('a=1')
elif a==2:
    print('a=2')
else:
    print('a!=1&a!=2')

循环语句

Python常用while和for循环语句，下面依次介
绍

where 循环语句

a=10
while a>0:
    print(a)
    a=a-1

for 循环语句

for 语句可以直接循环元素，也可以循环索引

#循环元素
a=[1,2,3,4,5]
for i in a:
    print(i)

1
2
3

#循环索引
for i in range(0,10):
    print(i)

break打破循环

可以直接使用break中止循环

for i in range(0,10):
    if i==5:
        break
    print(i)

字典数据类型

字典的典型特点就是键值对，以花括号标识

user={
    'name':'yd0ng',
    'sex':'man'
    }
print(user['name'])
user['age']=21
print(user)

列表推导式

alist=[]
for i in range(1,11):
    if(i%2==0):
        alist.append(i*i)
print(alist)

等同于

1 2	alist=[i*i for i in range(1,11) if(i%2)==0] print(alist)

字典推导式

dic={'123':123,'456':456}
for key in dic:
    dic[key]=0
print(dic)

等同于

1 2	dic={key:0 for key in dic} print(dic)

文件操作

打开文件

Python使用open()来打开文件

模式：读取为r(read),写入为w(write),追加为a(add)

记住使用完及时关闭文件

1 2	f=open('example.txt','w') f.close()

关闭文件

Python使用close()来关闭文件

记住使用完及时关闭文件

1 2	f=open('example.txt','w') f.close()

输出

Python使用write()来进行输出

1
2
3

f=open('example.txt','w')
f.write("hello world ")
f.close()

输入

Python使用read()来进行输入

f=open('example.txt','r')
text=f.read()
f.close()
print(text)

输入一行

Python使用readline()来进行单行输入

f=open('example.txt','r')
text=f.readline()
f.close()
print(text)

输入多行

Python使用readlines()来进行多行输入

f=open('example.txt','r')
for line in f.readlines():
    print(line)
f.close()

查看文件指针位置

f=open('example.txt','r')
print(f.tell())
f.read(1)
print(f.tell())

文件内移动

Python使用seek()来进行文件内移动
f.seek(len,status)

len为偏移的长度

status为偏移起始位置，0为从文件开头偏移，1为从当前位置偏移，2位从文件结尾偏移

1
2
3

f=open('example.txt','r')
f.seek(0) #文件指向相对位置，0ji开头
f.seek(5,0)

异常处理

Python使用try except Exception[,reason] finally 来捕获异常

a=3
b=0
try:
    print(a/b)
except ZeroDivisionError as e:
    print("除数无法为0",e)
finally:
    print("程序执行完成")

也可以使用raise主动引发异常

try:
    raise NameError('helloError')
except NameError:
    print("my custom error")

函数

函数定义

Python中使用def来进行函数定义

1
2
3

def 函数名(必选参数列表,*可选参数):
    代码块
    return 返回值

在函数中可以用global 声明为全局变量

迭代器函数

list1=[1,2,3]
it=iter(list1)
print(next(it))
print(next(it))

生成器函数

def frange(start,stop,step):
    x=start
    while x<stop:
        yield x
        x+=step
for i in frange(10,20,0.5):
    print(i)

lambda表达式

简单函数可以转化为lambda表达式

1 2	def add(x,y): return x+y

等同于

1	lambda x,y:x+y

内建函数

filter()

1
2
3

a=(1,3,5,7)
b=4
list(filter(lambda x: x<b ,a)) #取出a中小于b的元素

map()

a=[1,2,3]
list(map(lambda x:x,a))
b=[4,5,6]
list(map(lambda x:x+1,b))
list(map(lambda x,y:x+y ,a,b))

reduce()

1 2	from functools import reduce print(reduce(lambda x,y:x+y,[2,3,4],1))

zip()

1	zip((1,2,3),(4,5,6))

闭包

闭包可以优化函数使用

def sum(a):
    def add(b):
        return a+b
    return add
num=sum(2)
print(num(4))

要区分函数的调用和引用

装饰器

装饰器通常用@来进行标识

不传参数

import time
def timmer(func):
    def warpper():
        start_time=time.time()
        func()
        stop_time=time.time()
        print("运行时间是%s秒"%(stop_time-start_time))
    return warpper

@timmer
def i_can_sleep():
    time.sleep(3)

i_can_sleep()

带参数

def tips(argv):
    def tips(func):
        def nei(a,b):
            print("start %s %s"%(argv,func.__name__))
            func(a,b)
            print("stop")
        return nei
    return tips

@tips('add')
def add(a,b):
    print(a+b)

print(add(4,5))

上下文管理器

1
2
3

with open('name.txt') as f:
    for line in f:
        print(line)

模块

1 2	import module_name as new_name from module_name import method_name

PEP8编码规范

https://www.python.org/dev/peps/pep-0008/

1	pip install autopep8

类与实例

开始由面向过程的编程方法转向面向对象的编程方法

demo

class Player():
    def __init__(self,name,hp):
        self.name=name
        self.hp=hp
    def print_role(self):
        print("%s: %s"%(self.name,self.hp))
    def updateName(self,newname):
        self.name=newname

user1=Player('xiaoming',100)
user2=Player('xiaohong',90)
user1.print_role()
user2.print_role()
user1.updateName("xiaogang")
user1.print_role()

类的继承

基本概念

父类与子类
继承与多态
属性与方法

所有类都继承自object父类，可以用type查看类的类型，用isinstance进行判断

class Monster():
    '定义怪物类'
    def __init__(self,hp=100):
        self.hp=hp
    def run(self):
        print('移动到某个位置')
    def whoami(self):
        print("我是怪物父类")
class Animals(Monster):
    '普通怪物'
    def __init__(self,hp=10):
        super().__init__(hp)
class Boss(Monster):
    'Boss'
    def whoami(self):
        print("我是Boss子类")

a1=Monster(100)
print(a1.hp)
a1.run()
a2=Animals(1)
print(a2.hp)
a2.run()
a2.whoami()
a3=Boss(800)
a3.whoami()
print(type(a1))
print(type(a2))
print(type(a3))
print(isinstance(a1,Monster))

类与with结合

可减少异常处理机制的复杂性

class Testwith:
    def __enter__(self):
        print("run")
    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_tb is None:
            print("正常结束")
        else:
            print("has error %s"%exc_tb)

with Testwith():
    print("This is runing")
    raise NameError('testNameError')

多线程编程

每运行一个程序，会形成一个进程

demo1

import threading
import time
from threading import  current_thread
def myThread(arg1,arg2):
    print(current_thread().getName(),'start')
    print("%s %s"%(arg1,arg2))
    time.sleep(1)
    print(current_thread().getName(), 'stop')

for i in range(1,6):
    # t1=myThread(i,i+1)
    t1=threading.Thread(target=myThread,args=(i,i+1))
    t1.start()
print(current_thread().getName(),'end')

demo2

import threading
from threading import current_thread

class myThreading(threading.Thread):
    def run(self):
        print(current_thread().getName(),'start')
        print('run')
        print(current_thread().getName(),'stop')

t1=myThreading()
t1.start()
t1.join()
print(current_thread().getName(),'end')

消费者与生产者问题

from threading import Thread,current_thread
import time
import random
from queue import  Queue

queue=Queue(5)
class ProducerThread(Thread):
    def run(self):
        name=current_thread().getName()
        nums=range(100)
        global queue
        while True:
            num =random.choice(nums)
            queue.put(num)
            print("生产者%s生产了数据%s"%(name,num))
            t=random.randint(1,3)
            time.sleep(t)
            print('生产者%s睡眠了%s秒'%(name,t))
class ConsumerThread(Thread):
    def run(self):
        name=current_thread().getName()
        global queue
        while True:
            num=queue.get()
            queue.task_done()
            print("消费者%s消费了数据%s"%(name,num))
            t=random.randint(1,5)
            time.sleep(t)
            print('消费者%s睡眠了%s秒'%(name,t))


p1=ProducerThread(name='p1')
p1.start()
p1=ProducerThread(name='p2')
p1.start()
p1=ProducerThread(name='p3')
p1.start()
c1=ConsumerThread(name='c1')
c1.start()
c2=ConsumerThread(name='c2')
c2.start()

标准库定义

https://docs.python.org/3/library/index.html

常用模块介绍

正则表达式

元字符

. 匹配任意的单个字符
* 前一字符匹配零次或多次
+ 前一字符匹配一次或多次
? 前一字符匹配零次或一次
{m} 匹配m次
{m,n} 匹配m-n次
^ 匹配开头
$ 匹配结尾
[] 匹配括号内的任意字符
| 或
\d 匹配任意数字
\D 匹配非数字
\s 匹配字符
() 进行分组
^S 匹配空行
.*? 不使用贪婪模式(贪婪模式会尽可能长的匹配)

match()

match要求需要知道完整的模式，需要完全匹配

demo1

1
2
3

import re
p = re.compile('ca*t')
print(p.match('caaaaaaaat'))

demo2

import re
p = re.compile(r'(\d+)-(\d+)-(\d+)')
print(p.match('2018-05-06').group(0))
print(p.match('2018-05-06').group(1))
print(p.match('2018-05-06').group(2))
print(p.match('2018-05-06').group(3))
print(p.match('2018-05-06').groups())

research()

research是模糊匹配，实现的实际是搜索功能

demo3

import re
p = re.compile(r'(\d+)-(\d+)-(\d+)')
print(p.search('aaa2018-05-06aaa'))
print(p.search('2018-05-06'))

sub()

sub可以实现替换的功能

demo4

import re
phone="123-456-789#这是电话号码"
p2=re.sub(r'#.*$','',phone)
print(p2)
p3=re.sub(r'\D','',p2)
print(p3)

findall()

import re
phone="123-456-789"
result=re.findall('\d{3}',phone)
print(result)

时间和日期

time模块

import time

print(time.time())
print(time.localtime())
print(time.strftime('%Y-%m-%d %H:%M:%S'))

datatime

import datetime

print(datetime.datetime.now())
newtime= datetime.timedelta(minutes=10)
print(datetime.datetime.now()+newtime)

one_day=datetime.datetime(2008,5,27)
newdate=datetime.timedelta(days=10)
print(one_day+newdate)

数学相关库

math

1 2	import math print(math.cos(1))

random

import random
a=random.randint(1,5)
print(a)
b=random.choice(['aa','bb','cc'])
print(b)

文件与文件夹操作

os

import os
print(os.path.abspath('.'))
print(os.path.abspath('..'))
print(os.path.exists('/Users'))
print(os.path.isfile('/Users'))
print(os.path.isdir('/Users'))
print(os.path.join('/tmp/a/','b/c'))

pathlib

from pathlib import Path

p=Path('.')
print(p.resolve())
a=[x for x in p.iterdir() if x.is_file()]
print(a)
q=Path('/tmp/a')
Path.mkdir(q,parents=True)

科学计算与机器学习

numpy

import numpy as np

arr1=np.array([2,3,4])
print(arr1)
print(arr1.dtype)

arr2=np.array([1.2,2.3,3.4])
print(arr2)
print(arr2.dtype)

print(arr1+arr2)
print(arr2*10)

data=[[1,2,3],[4,5,6]]
arr3=np.array(data)
print(arr3)
print(arr3.dtype)

arr4=np.zeros((3,5))
print(arr4)

arr5=np.ones((4,6))
print(arr5)

arr6=np.empty((2,3,2))
print(arr6)

arr7=np.arange(10)
print(arr7)
print(arr7[2:8])
arr7[4:6]=10
print(arr7)

arr8=arr7[3:7].copy()
print(arr8)
arr8[:]=15
print(arr8)

pandas

Series

from pandas import Series,DataFrame
import pandas as pd

obj =Series([4,5,6,-7])
print(obj)
print(obj.index)
print(obj.values)

obj2=Series([4,7,-5,3],index=['d','b','c','a'])
print(obj2)
obj2['c']=6
print(obj2)
print('f' in obj2.index)
print(3 in obj2.values)

data={'beijing':35000,'shanghai':71000,'guangdong':16000,'shenzhen':5000 }
obj3=Series(data)
print(obj3)
obj3.index=['bj','gz','sh','sz']
print(obj3)

DataFrame

from pandas import Series,DataFrame
import pandas as pd
import numpy as np

data ={'city':['shanghai','shanghai','shanghai','beijing','beijing'],
       'year':[2016,2017,2018,2017,2020],
       'pop': [1.5,1.7,3.6,2.4,2.9]}

frame = DataFrame(data)

frame2=DataFrame(data,columns=['year','city','pop'])

print(frame)
print(frame2)

print(frame2['city'])
print(frame2.year)

frame2['new']=100
print(frame2)

frame2['cap'] = frame2.city=='beijing'
print(frame2)

pop={'beijing':{2008:1.5,2009:2.0},
     'shanghai':{2008:2.0,2009:3.6}
}

frame3=DataFrame(pop)
print(frame3)
print(frame3.T)

obj4=Series([4.5,7.2,-5.3,3.5],index=['b','d','c','a'])
print(obj4)
obj5=obj4.reindex(['a','b','c','d','e'],fill_value=0)
print(obj5)

obj6=Series(['blue','purple','yellow'],index=[0,2,4])
print(obj6.reindex(range(6),method='ffill'))
print(obj6.reindex(range(6),method='bfill'))

from numpy import nan as NA
data=Series([1,NA,2])
print(data)
print(data.dropna())

data2=DataFrame([
    [1.,6.5,3],
    [1.,NA,NA],
    [NA,NA,NA]
])
print(data2)
print(data2.dropna())
print(data2.dropna(how='all'))
data2[4]=NA
print(data2)
print(data2.dropna(axis=1,how='all'))

# data2.fillna(0)
print(data2.fillna(0))
print(data2.fillna(0,inplace=True))
print(data2)

data3=Series(np.random.randn(10),
             index=[['a','a','a','b','b','b','c','c','d','d'],
             [1,2,3,1,2,3,1,2,2,3]])

print(data3)
print(data3.unstack())
print(data3.unstack().stack())
print(data3['b':'c'])
print(data3.b)

matplotlib

import matplotlib.pyplot as plt
import numpy as np
# 简单曲线
plt.plot([1,3,5],[4,8,10])
plt.show()

#复杂单条曲线
x=np.linspace(-np.pi,np.pi,100)
plt.plot(x,np.sin(x))
plt.show()

#复杂多条曲线
x=np.linspace(-np.pi*2,np.pi*2,100)
plt.figure(1,dpi=50)
for i in range(1,5):
    plt.plot(x,np.sin(x/i))
plt.show()

#绘制直方图
plt.figure(1,dpi=50)
data=[1,1,1,2,2,3,3,4,5,5,6,4]
plt.hist(data)
plt.show()

# 绘制散点图
x=np.arange(1,10)
y=x
fig=plt.figure()
plt.scatter(x,y,c='r',marker='o')
plt.show()

读取文件绘图

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

iris=pd.read_csv("./test.csv")
print(iris.head())
iris.plot(kind="scatter",x="120",y="4")
plt.show()

seaborn

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

import warnings
warnings.filterwarnings('ignore')

iris=pd.read_csv("./test.csv")

sns.set(style='white',color_codes=True)

sns.jointplot(x='120',y='4',data=iris,size=5)

sns.distplot(iris['120'])
plt.show()

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

iris=pd.read_csv("./test.csv")

sns.set(style='white',color_codes=True)
sns.FacetGrid(iris,hue='virginica',size=5).map(plt.scatter,'120','4').add_legend()

plt.show()

tensorflow

网络数据采集

urllib

简单记一下吧，我一般不用这个，我会选择直接用requests库

demo

from urllib import request

url='http://www.baidu.com'
response=request.urlopen(url,timeout=1)
print(response.read().decode('utf-8'))

GET 与POST 请求方式测试

from urllib import request
from urllib import parse


# GET 请求
response=request.urlopen('http://127.0.0.1/get',timeout=1)
print(response.read().decode())

# POST请求

data=bytes(parse.urlencode({'word':'hello'}),encoding='utf-8')

response2=request.urlopen('http://127.0.0.1/post',data=data)
print(response2.read().decode())

超时连接

from urllib import request
import socket
import urllib

try:
    response=urllib.request.urlopen('http://httpbin.org/get',timeout=1)
except urllib.error.URLError as e:
    if isinstance(e.reason,socket.timeout):
        print("Time OUT")

请求头部伪造

from urllib import parse
from urllib import request

header={
    'X-Forwarded-For': '127.0.0.2'
}

data={
    'word':'hello'
}
# POST请求
url='http://127.0.0.1/post'
data=bytes(parse.urlencode(data),encoding='utf-8')
# header=bytes(parse.urlencode(header),encoding='utf-8')
req=request.Request(url=url,data=data,headers=header,method='POST')
response=request.urlopen(req)
print(response.read().decode('UTF-8'))

requests

好东西，我喜欢用，Web选手必备技能

import requests

# # GET请求
# url='http://127.0.0.1/get'
# data={
#     'key':'value',
#     'abc':'xyz'
# }
# response=requests.get(url,data)
# print(response.text)

#POST请求
url='http://127.0.0.1/post'
data={
    'key':'value',
    'abc':'xyz'
}
response=requests.post(url,data)
print(response.text)
print(response.json())

正则+requests爬取网络图片

import requests
import re
url="http://www.cnu.cc/discoveryPage/hot-人像"
content= requests.get(url).text
print(content)

pattern=re.compile(r'<a href="(.*?)".*?title">(.*?)</div>',re.S)
results=re.findall(pattern,content)
# print(results)
for result in results:
    url,name=result
    print(url,re.sub('\s','',name))

BeautifulSoup

基本用法

from bs4 import BeautifulSoup
import requests
res=requests.get('http://www.baidu.com')
res.encoding='UTF-8'
html_doc=res.text
soup =  BeautifulSoup(html_doc,'lxml')

#html格式化
print(soup.prettify())

#打印title标签里的内容
print(soup.title.string)

#查找p标签
print(soup.p)

#查找p标签id的名字
print(soup.p['id'])

#查找a标签
print(soup.a)

#查找id为lh的标签
print(soup.find(id='lh'))

#查找所有a标签
print(soup.find_all('a'))

#查找所有a标签的链接
for link in soup.find_all('a'):
    print(link.get('href'))

#找到所有的文本内容
print(soup.get_text())

爬取网络图片

from bs4 import BeautifulSoup
import requests
import shutil
import os
import re
def download_jpg(image_url,image_localpath):
    response=requests.get(image_url,stream=True)
    if response.status_code == 200:
        with open(image_localpath+'.jpg','wb') as f:
            response.raw.decode_content=True
            shutil.copyfileobj(response.raw,f)
def crwa(url):
    res=requests.get(url)
    res.encoding='utf-8'
    html_doc=res.text
    soup=BeautifulSoup(html_doc,'lxml')
    # print(soup)
    imgall=soup.find_all('img')
    dic={}
    for img in imgall:
        dic[img.get('alt')]=re.sub('\?.*','',img.get('src'))
    print(dic)
    for name in dic:
        # print(name,dic[name])
        dir = os.path.abspath('./images')
        # print(dir)
        imgpath=os.path.join(dir,name)
        print("开始下载%s"%name,dic[name])
        download_jpg(dic[name],imgpath)

url="http://www.cnu.cc/discoveryPage/hot-人像"
crwa(url)

本文作者： yd0ng
本文链接： https://yd0ng.github.io/2020/02/11/Python%E7%BC%96%E7%A8%8B%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！