Python3 学习笔记
作者: dkvirus 发表于: 2018-09-19 15:19:54 最近更新: 2018-10-16 17:23:24

学习资料来自 廖雪峰 python 教程

一、数据类型

  • str 字符串
  • int 数字
  • bool 布尔值
  • list 列表(数组)
  • tuple 元组
  • dict 字典
  • None 空

1. 字符串

1)在 .py 里写中文,文件顶部加上 # coding=utf8

2)在 r'' 里面写字符串不转义,写的啥,显示的也就是啥。

1
2
3
4
>>> print('\\\t\\')
\ \
>>> print(r'\\\t\\')
\\\t\\

3)在 b'' 里面写字符串自动转为以字节为单位。

1
2
x1 = 'ABC'
x2 = b'ABC'

x1 是字符串,x2 是字符串的字节表示,字符串中一个字符由若干个字节组成。

encode() 将字符串编码为字节流,decode() 将字节流转为字符串,读取文件 api 读的都是字节流。

4)换行字符串写在 ''' '''' 里面。

1
2
3
4
5
6
7
8
9
10
print('''
hello
world
dkvirus!
''')

# 打印结果如下:
hello
world
dkvirus!

5)len()

计算字符串的字符个数,如:len('ABC')

6)% —— 字符串模板

1
2
3
4
>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'
  • %d —— 整数
  • %s —— 字符串
  • %f —— 浮点数
  • %x —— 十六进制

请问,日期格式怎么写??不确定什么格式,就用 %s

js 中处理字符串模板是目前遇到最最简洁方便的。

7)字符串格式化

相比于 %s,还要考虑数据类型,使用 format 函数格式化字符串只要关注参数位置即可。

1
2
3
4
5
import time

'Hello, i am {0}, {1} years old, today is {2}'.format('dkvirus', 24, time.time())

# 打印:'Hello, i am dkvirus, 24 years old, today is 1539680603.2218869'

8)其它类型的值转为字符串

任何类型都可以通过 str() 转为字符串类型。

1
2
3
4
>>> str(1.23)
'1.23'
>>> str(100)
'100'

2. 数值

整数、浮点数(小数)。

int() 函数可以将其它数据类型的值转换为整数,float() 函数可以转换为小数。

1
2
3
4
5
6
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34

3. 布尔值

True 和 False。

andornot 表示与或非,这三个运算符没有 js 里 &| 来的简洁。

bool() 函数可以将其它类型的值转换为布尔值。

1
2
3
4
>>> bool(1)
True
>>> bool('')
False

4. 列表

python 里的列表(List)相当于 js 里的数组,java 中的 List 集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
num = [1, 2, 3]

# 增
num.append(4) # 往列表中追加一个元素
num.append(1, 5) # 往列表下标为1的位置添加一个元素

# 删
num.pop() # 删除列表末尾一个元素
num.pop(1) # 删除列表下标为1的位置的元素

# 改
num[1]=2 # 替换列表下表为1的位置的元素的值

# 查
num # 输出列表数据
num[-1] # 输出列表中最后一个元素
len(num) # 计算列表长度

# 切片。字符串和元组也可以看成是特殊的列表,也拥有切片特性
num[0:2] # 取列表中前2个元素,下标 [0, 2),不包括下标 2 的元素
num[:2] # 同上,第一个索引是 0 可以省略不写
num[-2:-1] # -1 表示倒数第一个元素,这里是取倒数第二个元素
num[-2:] # 同上
num[0:10:2] # 取前十个元素,并且是间隔取值
num[::5] # 所有元素,每隔5个取一个
num[:] # 复制一个列表

只有能进行遍历的数据类型才能使用 list() 转换为列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a = 'dkvirus'
b = 24
c = True
d = [ 1, 2, 3 ]
e = ( 1, 2, 3)
f = { 'name': 'dkvirus', 'age': 24 }
g = None

list(a) # ['d', 'k', 'v', 'i', 'r', 'u', 's']
list(b) # int 数字不能遍历,报错
list(c) # bool 布尔值不能遍历,报错
list(d) # [1, 2, 3]
list(e) # [1, 2, 3]
list(f) # 默认获取字典的键组成的元组 ['name', 'age']
list(f.values()) # 可以获取字典值组成的元组 ['dkvirus', 24]
list(g) # NoneType 空不能遍历,报错

5. 元组

tuple,写在 小括弧 里,和列表写法很相似,初始化值之后可以查看值,不能再修改值。

1
2
3
4
num = (1, 2, 3)

num2 = (1) # 不是元素,单纯的小括弧里数值1
num3 = (1,) # 元组中只有一个元素,后面要加个逗号与单纯的小括弧进行区分

只有能进行遍历的数据类型才能使用 tuple() 转换为元组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a = 'dkvirus'
b = 24
c = True
d = [ 1, 2, 3 ]
e = ( 1, 2, 3)
f = { 'name': 'dkvirus', 'age': 24 }
g = None

tuple(a) # ('d', 'k', 'v', 'i', 'r', 'u', 's')
tuple(b) # int 数字不能遍历,报错
tuple(c) # bool 布尔值不能遍历,报错
tuple(d) # (1, 2, 3)
tuple(e) # (1, 2, 3)
tuple(f) # 默认获取字典的键组成的元组 ('name', 'age')
tuple(f.values()) # 可以获取字典值组成的元组 ('dkvirus', 24)
tuple(g) # NoneType 空不能遍历,报错

6. 字典

dict,写在 花括弧 里,相当于 js 里的对象字面量,java 里的 Map 集合。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dict = { 'name': 'dkvirus', 'age': 30 }

dict['height'] # 键不存在会报错,js 里键不存在返回值 undefined
'height' in dict # 键在字典里返回 True,不在返回 False

# 遍历字典,迭代 key 值
for key in dict:
print(key) # 'name', 'age'

# 遍历字典,迭代 value 值
for value in dict.values():
print(value) # 'dkvirus', 30

# 遍历字典,同时迭代 key, value 值
for key, value in dict.items():
print('key is %s, value is %s' % (key, value))

二、基础语句

1. 条件语句

1
2
3
4
5
6
if 条件1:
表达式1
elif 条件2:
表达式2
else:
表达式3

2. 循环语句

遍历列表(List)和元组(tuple)。

1
2
3
nums = [1, 2, 3]
for num in nums:
print(num)

使用 while 写循环语句。

1
2
3
4
5
L = []
n = 1
while n <= 99:
L.append(n)
n = n + 2

break 语句:退出当前循环,循环结束,不再循环;
continue 语句:跳过当前循环继续执行下一次循环。

3. 输入语句

1
2
year = input('请输入当前年份:')
# year 即便输入的是数字,也是字符串类型,需要用 int(year) 转换为数值类型

三、函数

python 内置了很多有用的函数,详见 python 内置函数

定义函数:

1
2
def sum(a, b):
return a + b
  • def:定义函数,看到它,就知道它后面的就是函数了;
  • sum:函数名,自定义;
  • (a, b):函数需要的参数;
  • return:函数是用来处理问题的,最终需要将处理结果返回出去。

函数其它特性:

  • 模块内部函数命名时用下划线 _ 开头,表示不希望外部使用这个模块内的函数;
  • 可以返回多个值,在 js 中直到 ES6 才支持这个特性,python3 已经支持了,👍;
  • 参数可以设置默认值,这也是个不错的特性,在 js 中也是 ES6 版本才添加的特性,👍;
  • 在 js 中,...[1, 2, 3] => 1, 2, 3;在 python 中 *[1, 2, 3] => 1, 2, 3

四、模块化

1. 引用模块

一个 xx.py 文件就是一个模块。

import <libname> 导入外部库中所有函数,如果只要导入部分函数,使用 from <libname> import <function_name> 语句。

1
2
import time
from bs4 import BeautifulSoup

2. 模块名称变量

python 里提供了一个变量 __name__ 用来表示模块的名称。

1
2
3
# index.py
if __name__ = '__main__':
print('执行')
1
2
# main.py
import index

if __name__ == '__main__' 的意思是:

当执行 $ python index.py 时(直接运行模块本身),此时 __name__ 的值是一个固定值 '__main__'if __name__ == '__main__' 之下的代码块将被运行;

当执行 $ python main.py 时,因为 main.py 中引入了 index.py,因此 index.py 也会被执行(在其它模块中运行的 index.py 模块),此时 index.py 文件里的 __name__='index',index.py 内部的 if __name__ == '__main__' 里面的代码块不被运行。

五、web

1. 原生 http 请求 demo

python 内置模块 wsgiref (Web Server Gateway Interface Ref)提供 http 接口。

server.py 调用 http 接口,启动监听 8000 端口。

1
2
3
4
5
6
7
8
# coding=utf8
from wsgiref.simple_server import make_server
from hello import application

httpd = make_server('', 8000, application)
print('Serving HTTP on port 8000...')
# 开始监听HTTP请求:
httpd.serve_forever()

hello.py 编写路由,响应 http 请求。

1
2
3
4
# environ 是请求对象,start_response 是响应对象
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return [b'<h1>Hello, web!</h1>']

启动 web 服务 $ python server.py,在页面访问 localhost:8000 即可看到响应内容。

上面写法只能处理 http 请求,针对不同的请求地址(url)应当有不同的处理方法,此时需要通过 environ 请求对象判断 method 和 url,写起来让代码变得冗余。示例代码如下:

1
2
3
4
5
6
7
8
def application(environ, start_response):
method = environ['REQUEST_METHOD']
path = environ['PATH_INFO']
if method=='GET' and path=='/':
return handle_home(environ, start_response)
if method=='POST' and path='/signin':
return handle_signin(environ, start_response)
...

http 请求传参有三种方式:

  • restful 形式。http://localhost/user/:name => http://localhost/user/dkvirus,参数拼接再 url 里。获取方式:body = '<h1>Hello, %s!</h1>' % (environ['PATH_INFO'][1:] or 'web')
  • http://localhost/user?name=dkvirus,同样是拼接在 url 里,写在问号后面。获取方式 TODO
  • http://localhost/user 请求参数放在请求体 body 中。获取方式 TODO

2. web 框架 flask

使用前先安装 $ pip install flask。使用起来和 nodejs 里的 express 大同小异,web 框架帮助开发者处理请求地址、请求方式等杂事,开发者只需专心处理请求处理函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from flask import Flask
from flask import request

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def home():
return '<h1>Home</h1>'

# 接收 rest 风格的参数
@app.route('/user/<username>')
def show_user_profile(username):
# show the user profile for that user
return 'User %s' % username

@app.route('/post/<int:post_id>')
def show_post(post_id):
# show the post with the given id, the id is an integer
return 'Post %d' % post_id

if __name__ == '__main__':
app.run()

python 中其它 web 框架有:Djangoweb.pyBottleTornado

4. 模板引擎

python 中模板引擎 jinja2,使用前先安装 $ pip install jinja2。通过 render_template() 渲染模板,也就是将模板翻译成纯 html。

1
变量写在 {{ }} 里,如:{{ message }}。

写条件语句。

1
2
3
{% if message %}
<p style="color:red">{{ message }}</p>
{% endif %}

写循环语句。

1
2
3
{% for i in page_list %}
<a href="/page/{{ i }}">{{ i }}</a>
{% endfor %}

MVC(model - view - controller)

  • view 模板引擎即视图;
  • controller web路由即控制器,如 python 里的 flask,node 里的 express,java 里的 SpringMVC;
  • model 控制器往视图传的值即模型,如 python 中:render_template('signin-ok.html', username=username) 里面的 username=username 就是模型。

六、包管理工具 pip

1. 安装

已安装 python 前提下安装 pip。

1
$ sudo easy_install pip

2. 使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
Usage:
pip <command> [options]
Commands:
install Install packages.
download Download packages.
uninstall Uninstall packages.
freeze Output installed packages in requirements format.
list List installed packages.
show Show information about installed packages.
check Verify installed packages have compatible dependencies.
config Manage local and global configuration.
search Search PyPI for packages.
wheel Build wheels from your requirements.
hash Compute hashes of package archives.
completion A helper command used for command completion.
help Show help for commands.

General Options:
-h, --help Show help.
--isolated Run pip in an isolated mode, ignoring environment variables and user configuration.
-v, --verbose Give more output. Option is additive, and can be used up to 3 times.
-V, --version Show version and exit.
-q, --quiet Give less output. Option is additive, and can be used up to 3 times (corresponding to WARNING,
ERROR, and CRITICAL logging levels).
--log <path> Path to a verbose appending log.
--proxy <proxy> Specify a proxy in the form [user:passwd@]proxy.server:port.
--retries <retries> Maximum number of retries each connection should attempt (default 5 times).
--timeout <sec> Set the socket timeout (default 15 seconds).
--exists-action <action> Default action when a path already exists: (s)witch, (i)gnore, (w)ipe, (b)ackup, (a)bort).
--trusted-host <hostname> Mark this host as trusted, even though it does not have valid or any HTTPS.
--cert <path> Path to alternate CA bundle.
--client-cert <path> Path to SSL client certificate, a single file containing the private key and the certificate in
PEM format.
--cache-dir <dir> Store the cache data in <dir>.
--no-cache-dir Disable the cache.
--disable-pip-version-check
Don't periodically check PyPI to determine whether a new version of pip is available for
download. Implied with --no-index.
--no-color Suppress colored output

七、面向对象编程

1. 概述

定义类

1
2
3
4
5
6
7
8
class Student(object):

def __init__(self, name, score):
self.name = name
self.score = score

def print_score(self):
print('%s: %s' % (self.name, self.score))

创建对象并调用方法

1
2
3
4
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()
  • 类名约定大写;
  • 类可以继承其它类,不确定的话就是继承 object,写法:Student(object)
  • __init__ 函数起到构造函数的作用,可以初始化变量值;
  • self 表示实例本身;

2. 封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Student(object):

def __init__(self, name, score):
self.__name = name
self.__score = score

def print_score(self):
print('%s: %s' % (self.__name, self.__score))

def get_name(self):
return self.__name

def set_score(self, score):
self.__score = score
  • 封装。隐藏属性,外界通过实例方法操作内部属性;
  • 私有属性命名 __name,这样就无法通过实例对象调用内部属性,添加 get/set 方法调用内部属性;
  • __name__ 是正常命名,外界可以调用,_name 写法外界也可以正常调用;

3. 继承

1
2
3
4
5
6
7
8
9
class Animal(object):
def run(self):
print('Animal is running...')

class Dog(Animal):
pass

class Cat(Animal):
pass
  • 子类不用写代码就继承父类的方法;
  • 子类可以重写父类的方法;

4. 多态

1
2
3
4
5
6
7
8
9
b = Animal() # b是Animal类型
c = Dog() # c是Dog类型

>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True
>>> isinstance(c, Animal)
True
  • Dog 类继承 Animal 类,隐藏 c 对象不仅属于 Dog 类还属于 Animal 类;
  • isinstance() 可以判断对象是否属于某个类;
  • type() 可以打印对象属于那个类;
  • dir() 可以打印对象拥有的属性和方法;
首页
友链
归档
dkvirus
动态
RSS