分类 python 下的文章

Flask 中的上下文变量:

变量名上下文类别说明
current_app程序上下文指向处理请求的当前程序实例
g程序上下文替代python的全局变量,确保仅在当前请求中可用,用于存储全局数据,每次请求都会重设
request请求上下文封装客户端发出的请求报文数据
session请求上下文用于记住请求之间的数据,通过签名的Cookie实现

以上都是指向真实对象的代理,若需要获得原始对象,可以调用_get_current_object()方法。

以下代码保存了name这个值,并且可以供其他视图函数使用:

from flask import g

@app.before_request
def get_name():
    g.name = request.args.get('name')

@app.route('/hello')
def hello():
    return 'Hello, ' + g.name

1. HTTP请求

查询字符串
URL https://undefined.im/hello?name=Lily 中的?name=Lily即为查询字符串(query string)

一个完整的请求:

浏览器发送请求(request),报文(message)在浏览器和服务器之间传输,服务器根据请求返回的数据为响应报文(response message)。

常见的HTTP方法:

方法用途
GET获取资源
POST发送数据
PUT传输文件
DELETE删除资源
HEAD获得报文头部
OPTIONS询问支持的方法

Flask中的请求对象request

获取请求URL中的查询字符串参数:

request.args.get('name','默认值')
print request.args 
# {'name':value}

flask routes 命令
使用flask routes 命令可以查看所有路由

视图函数同时监听GET请求和POST请求:

@app.route('/api',methods=['GET','POST'])
def api():
    ...

转换器的使用:
转换器通过使用<转换器:变量名>(<int:age>)把变量转换成为整数。

@app.route('/api/<int:age>')
def api():
    ...

any 转换器:
any转换器可以设置可选值。

@app.route('/api/<any(blog,page,media):data>')
def api(data):
    ...

# 另外一种方式
dataType = ['blog','page','media']
@app.route('/api/<any(%s):data>'%str(data)[1:-1])
def api(data):
    ...

请求钩子
Flask 默认实现的5种请求钩子

钩子类型作用
before_first_request注册一个在第一个请求之前触发的函数
before_request注册一个在每个请求之前触发的函数
after_request注册一个如果没有异常抛出,则在请求之后触发的函数
teardown_request注册一个在每个请求之后触发的函数,如果发生异常,异常对象将作为参数
after_this_request在视图函数内注册一个在这个请求结束后出发的函数

注册一个钩子的基本示例

@app.before_request
def doSomething():
    pass
# 这个函数将在每个请求处理之前触发

2.HTTP 响应

视图函数可以返回最多由三个元素组成的元组:响应主体、状态码、首部字段。其中首部字段可以为字典,或是两元素元组组成的列表。

手工指定响应状态码

@app.route('/hello')
def hello():
    ...
    return 'hello'
    # 默认状态码为200

@app.route('/hello')
def hello():
    ...
    return 'hello',201
    # 指定状态码为201

重定向的方法

@app.route('/hello')
def hello():
    ...
    return redirect('https://notekit.cn/',302)
    # 重定向

@app.route('/hi')
def hi():
    ...
    return redirect(url_for('hello'))
    # 重定向到某个视图函数

搭建时花费了半天去解决过程中遇到的各种奇怪的坑,应当要记录下来。

virtualbox版本:6.0.14
vagrant 版本:2.2.6
box: ubuntu/xenial64

新建Box并导入

本地开发目录下(我的是X:development/env/xenial/):

vagrant init ubuntu/xenial64

会在目录下生成Vagrantfile,我做了如下配置:

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/xenial64"
  config.vm.network "private_network", ip: "192.168.33.20"
  config.vm.synced_folder "./www", "/vagrant"
  config.vm.provider "virtualbox" do |vb|
    vb.memory = "1024"
  end
end

Python配置

Linux 下大都自带了python,使用起来非常的方便,这个box自带了python3.5.2,因此直接在它的基础上安装pip和pipenv即可。

~$ python
Python 3.5.2 (default, Oct  8 2019, 13:06:37)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>  

安装pip

sudo apt-get install python-pip

安装pipenv

pip install pipenv

创建虚拟Flask开发环境

在项目目录中执行:

pipenv install

pipenv 创建虚拟开发环境

搭建Flask开发环境

安装flask

pipenv shell
pipenv install flask

测试项目

在项目目录中创建app.py文件并保存。

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return '<h1>:)</h1> Hello! Flask.'

保存后执行:

pipenv run flask run --port=8080 --host=0.0.0.0 
# 如果已经在虚拟环境下(即已经使用pipenv shell激活了虚拟环境
# 执行 flask run --port=8080 --host=0.0.0.0 即可

如果没有出现报错信息,console会提示如下:

  • Environment: production
    WARNING: This is a development server. Do not use it in a production deployment.

Use a production WSGI server instead.

你服务器的访问地址为0.0.0.0:8080,打开主机的浏览器输入http://192.168.33.20:8080 即可看到下图:

helloflask.JPG

现在,你就可以专心学习Flask了。

/app.py

""" flask 模板渲染,参数传递 """

# 引入Flask类,引入模板渲染方法
from flask import Flask, render_template

# 传入
app = Flask(__name__)

# 定义入口方法
@app.route('/')
def index():
    # return 'Hello!! Flask :)'
    """ 渲染index.html 并传入参数 title """
    return render_template('index.html',title = 'Flask')

# 运行
if __name__ == '__main__':
    app.run(debug=True, port=80, host='0.0.0.0')

# 开启debug, 设置端口号,设置主机名

/templates/index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ title }}</title>
</head>
<body>
     A page rendered by Flask with param 'title' = {{title}}
</body>
</html>

falsk是一款python下的轻量级Web框架,包含众多非常实用的插件,能够帮助你使用少量的代码构建功能完备的Web应用。

因为我是在Ubuntu 下做的开发,以下所有操作均在该系统下验证通过。
安装pip:

sudo apt install python-pip

安装flask框架:

pip install flask

一个简单的hello world

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello!! Flask :)'

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

运行后报错:

ModuleNotFoundError: No module named 'flask'

排查:
因为同时安装了python2和python3,在安装pip时执行的sudo apt install python-pip是在python2下安装的pip,应当执行sudo apt install python3-pip
同样的,在安装flask扩展时应当执行pip3 install flask

我非常肯定以后不会用到python2,所以干脆就把它卸载了:

# 卸载python2.7
sudo apt-get remove python2.7

# 卸载python2.7及其依赖
sudo apt-get remove --auto-remove python2.7

#消除python2.7
sudo apt-get purge python2.7 or sudo apt-get purge --auto-remove python2.7

修复以上错误后运行代码,控制台给出了web访问地址:
屏幕截图 2020-03-15 17.12.44.png

类的继承

子类可以及成父类中的变量和方法

在继承前必须要导入包含父类的模块
from model import class

父类模块:phone.py

class Phone():

    def __init__(self, number, local):
        self.number = number
        self.local = local

    def calling(self):
        print('calling '+ str(self.number) +' from ' + self.local)

    def message(self):
        print('message to ' + self.number )

子类模块:mobile.py

# 引入父类模块
from phone import Phone

class Mobile(Phone): # 继承的父类名写在括号内

    def __init__(self, number, local, url):
        self.url = url
        # 调用父类的构造方法
        super(Mobile,self).__init__(number, local) 
        
    
    def browser(self):
        print('browser to ' + self.url)
        super(Mobile,self).message() #调用父类方法

Mobile('152','636','baidu').calling() #调用继承的方法
Mobile('152','636','baidu').browser()
 

成员的可见性

为了提高封装性和安全性,需要根据实际情况对类的成员的可见性进行约束

class Test():
    
    def __init__(self,name='张三',course='英语'):
        self.name = name
        self.course = course
        self.score = 0
      

    def marking(self):
    
        print(self.name + '的' + self.course + '成绩为' + str(self.score))

s = Test(name='那谁')
s.score = 20 # score可以被外部调用并更改
s.marking() 
 

定义私有变量和方法

为了提高安全性,变量score需要设置为私有,禁止外部调用,设置私有变量和方法的可见性方法如下:
在名称前使用__即可声明一个私有变量或者方法。

class Test():
    
    def __init__(self,name='张三',course='英语'):
        self.name = name
        self.course = course
        self.__score = 0 #设置为私有
      

    def __marking(self):
        print(self.name + '的' + self.course + '成绩为' + str(self.__score))

    def showScore(self):
        print(self.__score)

s = Test(name='那谁')
print(s.__score)  #无法访问
s.showScore() 

可访问性

python通过修改变量名称实现属性和方法的私有性:

class Test():
    
    def __init__(self,name='张三',course='英语'):
        self.name = name
        self.course = course
        self.__score = 0
      

    def __marking(self):
        print(self.name + '的' + self.course + '成绩为' + str(self.__score))

    def showScore(self):
        print(self.__score)

s = Test(name='那谁')
s.__score = -1  # 新增了一个名为__score的变量,和s.score 不同
print(s.__dict__) 
# {'name': '那谁', 'course': '英语', '_Test__score': 0, '__score': -1} 
print(s._Test__score) # 魔术方法,强制访问私有变量 score

基本概念

:类是现实世界或者思维世界中的实体在计算机中的反应,它将数据以及对数据的操作封装在一起。
数据成员:用来表征对象特性的属性
成员方法:用来体现对象行为并且封装在类中的函数
类变量:类的变量,抽象层级
实例变量:对象的特征,现实层级
类和对象的关系:类是对某一类象的抽象化,通过类可以产生多个对象

类的声明

类名首字母应该大写,且遵循驼峰法C
定义一个类

class CivilEngineer():
    name = ''
    project = ''

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


    def eat(self):
        print(self.name + '负责了' + self.project )

实例化

按照不同的属性通过实例化生成不同的对象。

person = Person()
person.showInfo()

构造函数:

通过构造函数可以根据参数生成不同的对象,构造函数在类被实例化时会被自动调用,返回值只能为None

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

方法的定义

self和php中的$this以及JS中的this关键字作用相同,用来引入内部属性/数据成员或者方法。

    def showInfo(self):
        print(self.name + '今年' + str(self.age) + '岁' )

实例方法

def eat(self):
    print(self.name + '吃东西')

在实例方法的内部访问类变量

可以借助__class__访问类变量:

class Student():
    
    sum = 0 # 类变量
    
    def total(self):
        self.__class__.sum += 1 #操作类变量
        print(self.__class__.sum)


print(Student.sum) #获取类变量
Student().total() # 实例方法操作类变量

类方法

类方法主要用来操作类变量 声明方法如下

在定义方法前增加装饰器 @classmethod,参数列表中传入cls(可更改),类方法用来操作类变量

class Person:
    @classmethod
    def plus_sum(cls):
        pass

类方法对类变量的操作

class Person:
    sum = 0

    @classmethod
    def total(cls):
        print(cls.sum)

Person.total() # 类方法被类调用
Person().total() # 类方法被实例调用

从上面的代码中可以看出,类方法可以更加方便的引用并操作类变量,而不像实例方法那样需要借助__class

!!! 类方法可以被类和实例调用,但不建议使用实例对象调用类方法

静态方法

静态方法通过使用@staticmethod装饰器来声明

class Person:
    sum = 0

    @classmethod
    def total(cls):
        print(cls.sum)

    @staticmethod
    def add():
        print(Person.sum) #实例方法访问类变量
        print('static method')

Person.total() # 类调用类方法
Person.add()  # 类调用静态方法
Person().add() # 实例调用静态方法

python中不常使用静态方法,静态方法可以访问实例变量和类变量

函数基础知识

函数的作用:将常用功能封装起来,具有明确的功能,能够隐藏细节,减少代码复杂度,具有复用性,如下代码展示了一个函数:

a = 1.12356
print(round(a,2))
# round(number, ndigits=None)) // 四舍五入
# 控制台中输入 help(func) 可以快速查看内置函数信息
# 查看python 之禅 import this

函数的定义

语法:

def funcname(parameter_list):
    pass

parameter_list 可以没有;函数中使用return 返回值;如果没有return 则默认返回 None;函数执行到return后,即停止执行。

示例:

def add(x,y):
    result = x + y
    return result

 
def print(code):  
    print(code) 
#自定义函数不能和内置函数同名,自己调用自己 报错 Traceback

如何设置函数允许最大的递归层数

在文件头部声明:

import sys
sys.setrecursionlimit(10000)

形参和实参

def add(x,y):
    result = x + y
    return result
# x,y 形参

a = add(1,2)

# 1,2 实参

返回结果

同时返回多个结果

def damage(skill1,skill2):
     return skill1,skill2

同时接收多个参数

sk1_damages,sk2_damages = damage(3,6) # 序列解包方式 接收结果 
print(sk1_damages)

序列解包相关知识

a,b,c = 1,2,3
""" 
等同于
a = 1
b = 2
c = 3
"""
d = 1,2,3
# 等同于 
d = (1,2,3)
a,b,c = d
#另外一个例子
a=b=c=1
""" 
a = 1
b = 1
c = 1
"""

函数的参数

必须参数

函数参数列表中定义的参数必须传递,传递的参数参与到函数运算,必须参数在调用时必须考虑传入顺序。

def add(x,y)
    return x + y 
#在调用add函数时必须传入x,y,且按序
add(2,1)
# 关键字参数,调用时可忽略顺序
add(x=2,y=1)

默认参数

下面定义了一个不含默认参数的函数:

def print_student_info(name, gender, age, college):
    print('我叫' + name)
    print('我今年' + str(age) + '岁')
    print('我时' + gender + '生')
    print('我在' + college + '上学')
    print('-------------------------')

print_student_info('李小萌','女',17,'市三中')

下面定义了一个含有默认参数的函数
默认参数的定义:即给定了默认值的参数,定义和调用时默认参数需要放在参数列表最后

def print_student(name, gender='男', age=18, college='红星小学'):
    print('我叫' + name)
    print('我今年' + str(age) + '岁') 
    print('我时' + gender + '生')
    print('我在' + college + '上学')
    print('-------------------------')

print_student('李亮','女',12)

# 使用关键字传参
print_student('果果', age = 19)

调用时默认参数需要放在参数列表最后

print_student('丁丁',gender='女',17,college='大三鹿中学')
#  SyntaxError: positional argument follows keyword argument

包的概念

包可以看作是包含了很多模块的文件夹,声明包的方法是在目录中创建
__init__.py文件

模块

每个py文件都可以看做是一个模块,模块中可以包含类,方法(函数),且模块和模块之间可以相互引入。

命名空间

python中的命名空间表示为包名+.+模块名:

包content下的article模块:content.article

包的引入

# import as 用法
import content.article as artice 
#导入模块,引用模块中的变量date
import content.article
print(content.article.date)

# from module import a,def 用法 
# 导入变量title
from content.article import title
# 导入getText方法
from content.article import getText

!!! 当一个包或者包中的模块被引入时,__init__.py模块中的类,方法,变量将会被自动引用,这一特性同样可以用来解决批量引入时的问题。

统配符引入

from package.module import *
指定某模块下可以使用*号导出的元素,需要在模块中做如下声明:
__all__ = ['a','b'] // 只有a,b能通过*的方式引入,a,b可以时变量,也可以是模块

表达式

C语言中关于表达式的定义:表达式(Expression)是运算符(operator)和操作数(operand)所构成的序列。

1+1
a = [1,2,3]
a > b
1 + 2 * 3 # 有顺序
c = int('1') + 2 # 可调用函数

以上全部都是表达式。

优先级

a = 1
b = 2
c = 3
a + b * c # 7
a or b and c # 1  先计算 b and c, 返回3,再计算 a or 3,返回1

Python 优先级排序(查资料)

同优先级运算从左到右计算,否则按照优先级从高到低运算,如果需要刻意改变优先级,可使用()包含。
没有赋值运算符 = ,左结合,存在赋值运算符,右结合。

优先级:算数运算符 > 比较运算符 > 逻辑运算符。
not > and > or。

not 1 or 2 + 2 == 2 # 先计算2+2,然后计算4==4,再计算 not 1,得到结果False or False 返回False 

条件控制

python中的条件控制可以通过使用 if else,if elif else来实现,语法:

# if else 语法
if condition:
    pass
else:
    code

# if elif else 语法
if condition:
    code1
elif condition2:
    code2
else
    code3

!!! python中并没有switch语法,不过我们可以借助if elif 来实现同样的功能。
相关文档:https://docs.python.org/3/faq/design.html

循环控制

python中的循环控制可以使用while和for来实现,while循环尝试用在递归操作中,而for循环则常常用来遍历序列,集合,字典等。

while循环语法

CONDITION = True
while CONDITION:
    pass
# 以上是一个无限循环/死循环
count = 0
while count <= 11:
    count += 1
    print(count,end="|")
# 输出 0|1|2|3|4|5|6|7|8|9|10|

for 循环语法
下面的代码分别实现了循环输出一个列表和嵌套列表。

#列表循环
a = ['a','b','c','d']
for x in a:
    print(x)

# 列表和元组嵌套的场景
l = [['a','b','c','d'],(1,2,3)] 
for b in l:
    for c in b:
        print(c,end=' ')

# for else 用法
l = [['a','b','c','d'],(1,2,3)] 
for b in l:
    for c in b:
        print(c,end=' ')
else:
    print('遍历完成')

跳出语句 break continue

break 和 continue 仅能跳出当前循环,使用时应当注意。

# break

l =  ['a','b','c','d'] 
# 遇到 'c' 跳出
for c in l:
    if c == 'c':
        break
    print(c)
#  输出 ['a','b'] 

l =  ['a','b','c','d'] 
# continue 跳过c 输出
for c in l:
    if c == 'c':
        continue
    print(c,end='|')
#  输出  ['a','b','d'] 

可以借助range方法和for实现重复执行10次
range函数的用法:
range(start,end,step)

for x in range(0,10,2):
    print(x,end="|")
print('\r')
#  输出 0|2|4|6|8|

输出等差数列

for x in range(20,0,-2):
    print(x,end="|")
print('\r')
#  输出 18|16|14|12|10|...

打印指定间隔元素

l = [1,2,3,4,5,6,7,8,9,10]
for x in range(0,10,2):
    print(l[x],end="|")
print('\r')
# 输出 1|3|5|7|9|
 
# 改进

l = [1,2,3,4,5,6,7,8,9,10]
for x in range(0,len(l),2):
    print(l[x],end="|")
print('\r')
# 输出 1|3|5|7|9|

列表的切片可以通过如下方式实现:

l = [1,2,3,4,5,6,7,8,9,10]
s = l[0:len(l):2]
print(s)
# 输出 [1, 3, 5, 7, 9]

变量赋值操作(赋值符号 =

# 未使用变量
[1,2,3,4]*3+[1,2,3]+[1,2,3,4]
# [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 1, 2, 3, 4]
# 变量
a = [1,2,3,4] # 赋值
b = [1,2,3]  
a*3+b+a # 运算

Python变量名对大小写敏感,给变量起名一定要有意义,增强可读性,例如 skill,goodsId...
变量名可以使用数字,字母,下划线组成,首字母不能是数字。

_config ='config info"
user_info = 'user'

也不能用系统保留字作为变量名.
python 中的变量无需申明变量类型

float a = 10.0 
a = 10.0

注意以下现象:

a = 1
b = a
a = 3
print(b)
# 1 b没有随着a改变

a = [1,2,3]
b = a
a[0] = 6
print(b)
# [6,2,3] b 随着a变化

值类型和引用类型

值类型不可变,引用类型可变
int str tuple是值类型 list set dict是引用类型

a = "hello"
id(a) = 6522010 # 内容地址
a = a + "world" 
id(a) = 6522966 # 内存地址 
print(a) # hello world

列表修改

b  = [1,2,3] # 定义列表
b.append(4)
print(b) # [1,2,3,4] 可动态改变

元组不可追加,不可修改

(1,2,3) # 元组
a[2] = 1 # 报错 !!!

运算符

1.算数

算数运算符
+-*///%**
求和乘积整除求余乘方

!!! Python 中没有自增++ 和自减 --运算符

2.赋值

赋值运算符
=+=*=/=%=**=//=
赋值先求和再赋值先求积再赋值先除再赋值先求余再赋值先乘方再赋值先整除再赋值知

3.比较

比较运算符
==!=>>=<<=
等于不等大于大于等于小于小于等于

以下代码需要重点理解:

'abc' < 'abd' # ASII码逐个比较 a < a? b < b ? c < d? 序列特性
[1,2,3] < [1,2,4] # True
(1,2,3) > (1,2,4) # False
(1,2,3) < (2,1,3) # True  得到结果即返回
# 集合,字典同样是适用

4.逻辑

逻辑运算符
andornot
两个为真返回真一个为真返回真not True = False

int float
0False , 非0均为True
str
''False, '0'True
list
[]False

5.成员运算符

成员运算符
in是否在 1 in [1,2,3,4] 返回 True
not in是否不在 6 not in (1,3,4) True

成员运算符支持所有序列,包括字符串,元组,列表,集合,字典

a = 'key'
a in {'key':1} # True  成员运算符在字典中仅适用于key 查询
a in {'1':'key'} # False 
'a' in 'action'  # True

5.身份运算符

身份运算符
is
not is不是
a = 1
b = 1.0
a == b # True 关系运算符对值比较
a is b /# False 身份运算,比较内存地址
{2,1,3} == {1,2,3} # 集合 True 无序列表元素顺序不影响值
(1,2,3) == (2,1,3) # 元组 False 元组属于有序,会

关系运算符对值比较,身份运算比较内存地址;
变量类型判断

a = 1
isinstance(a,(int,float,str))

对象的三个特征: id、值、类型

5.位运算符

位运算符
&Ι^~<<>>
按位与按位或按位异或按位取反左移动右移动

按位与理解
把数字转成2进制后每一位进行比较,如果相同则返回1,不同则返回0

 #  2: 0b10
 #  3: 0b11
2 & 3
# 0b10
# 0b11
# 0b10 
# output:2   0b10
2 | 3
# 0b10
# 0b11
# 0b11 
# output: 3    0b11

nubmber 数字类型(整数(int),浮点数/小数(float)

>>> type(1)
<class 'int'>
>>>type(2/2)
<class 'float'>
>>>type(2//2) 
<class 'int'>

2进制,8进制,16进制

  • 十进制:10
  • 二进制: 0b10 (2)
  • 八进制:0O10 (8)
  • 十六进制: 0x1F(16)

进制转换:

  • 转换成二进制

       bin(10)
  • 转换成八进制

       oct(10)
  • 转换成十六进制

       hex(10)
    

bool 布尔类型:表示真和假的状态

True # 真 (非0非空)
False #  假 (0或none)
# Python中的True和False首字母必须大写

complex 复数

    36j # 表示复数

str 字符串

单引号,双引号,三引号表示字符串

'python'
"python"

三引号用来换行

'''
hello
hello
'''

"""
hello
hello """

转义字符 \
用来表示无法看见的字符,或者与语言本身冲突的字符

\n # 换行
\t # tab
\r # 回车

换行符 \

"hello\
world"

输出路径的方法

print(r'C:\windows\system32\bin')
# r用来申明原始字符串,大小写不敏感
print('C:\\windows\\system32\\bin')

字符串操作:

字符串运算

"hello"+"world" # 输出 hello world
"hello" * 3  # 输出 hello hello hello
"hello"[0] # 输入h 正序
"hello"[-1] # 输出 o 倒序
"hello world"[0:5] # 切片 输出 hello  
"hello world"[0:-1] # 切片 输出 hello worl
"hello python java #c javascript php"[6:] # 切片 输出 python java #c javascript php
"hello python java #c javascript php"[-3:] # 切片 输出 php

组/序列

表示组的方式有很多种:列表
列表list,元素可加入多种类型,可嵌套:

[1,2,3,4,5,6,'呵呵',True,['a','c']]

访问列表元素:

['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面']
['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面'][0] # 烤包子
['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面'][0:2] # ['烤包子','大盘鸡'] 切片操作
['烤包子','大盘鸡','抓饭','烤肉','过油肉拌面'][-1:] # ['过油肉拌面']

列表追加:

['1']+['b'] # ['1','b']

元组tuple,可参考列表
当元组中只有唯一一个元素时,元组将转换成该元素的类型

(1) # int
("string") # str

申明单个元素的元组

(1,) # tuple
("string",) # tuple

空元组

() # tuple

* 字符串,列表,元组均可看作是序列 *

延申:

逻辑运算

3 in [1,2,4,5] # False
3 not in [1,2,4,5] # True

常用计算

len('python') # 6 
max([1,3,7]) # 7
min([1,3,7]) # 1
max('python') # y 按照ASII码值排序
min('python') # h 字符串用空格会输出空格
ord('w') # 119

集合 set

区别于序列,集合时无序的一组元素组成的对象,集合会自动剔除重复的元素

集合的表示:

{1,2,3,4}
{1,2,3,4}[0] # 报错!!!
{1,1,3,4,6,6} # {1,3,4,6}

集合的操作:

len{1,2,3} # 3 获取长度
3 in {1,2,3} # True 判断集合中是否存在某元素
{1,2,3,4,5} - {3,4} # {1,2,5} 求集合的差集
{1,2,3,4,5} & {3,4} # {3,4} 求集合的交集
{1,2,3,4,5} | {3,4,7} # {1,2,3,4,5,7} 求集合的并集
set() //定义空集合

字典 dict

由很多键值对组成的集合, 字典中的键不能重复,键值必须时不可变的类型,字典可以嵌套

{key1:vaule1,key2:value2}
{'title':'内容标题','tag':{'mind':'心理学','development':'编程开发'},'content':'这是内容'}
joh = {'name':'Joh','age':29}
joh['name] # Joh

Python中的切片操作:

在Python中,我们甚至可以把字符串,一段文本看作是一个列表:

word = "welcome"
word[1:3]
# 输出elc  
mylist = [1,2,3,4,5,6]
mylist[2:5]
# 输出[3,4,5,6]
mylist[2:]
#另外一种写法
mylist[:3]
# 输出[1,2,3,4]

Python中的列表对象看起来和PHP中的数组对象非常相似,甚至连读写增删的方式都非常类似,下面这段代码实现了对一个列表对象所有元素的输出查询:

person = [
    'Gakiki',
    '29',
    'Cute',
    'Japanese',
    'Gakiki@ukot.jp',
    'http://gakiki.jp'
]

#len()可以获得列表长度(元素个数)
length = len(person)

# 利用for循环输出列表内容
for i in range(length):
    person[i]
    print(person[i])

上面可以看到在使用for循环时和PHP的区别,PHP的写法通常为for($i = 0 ,$i < $length), 而在Python中,相同条件的for循环应当这样写 for i in range(length)。

下面的例子实现了通过获取用户输入,输出月份名称和天数名称:


months = [
    'Jan',
    'Feb',
    'Mar',
    'Apr',
    'May',
    'Jun',
    'Jul',
    'Aug',
    'Sep',
    'Oct',
    'Nov',
    'Dec'
]

days = [
    'st',
    'nd',
    'rd',
    ] + 17 * ['th'] + [
    'st',
    'nd',
    'rd',
    ] + 7 * ['th']

userDay = int(input("请输入天:")) 
userMonth = int(input("请输入月:"))
theMonth = months[userMonth-1]
theDay = str(userDay) + days[userDay-1]  
print("Today is " + theDay + " " + theMonth + " 2018")

本例的实现时利用了日数,月数加上1即可成为于months和days列表中的对应名称/后缀元素的索引这一原理。
注意列表days的写法,使用了"+"进行了四个列表的拼接。
在处理天数和后缀因为int型和str无法合并运算时,使用了str(userDay)。