This post records some python instructions for fast search

变量和简单的数据类型

变量

变量通常被描述为一个盒子，里面装了特定的值在程序中可以随便修改变量的值，python始终记录变量的最新值

1
2
3
4
5
6
7


message = "hello world"
print(message)
message = "hello python"
print(message)
---
hello world
hello python 

1变量名只能包含字母、数字、下划线 2变量名不能包含空格，大部分情况用下划线 3Python的关键字不能用来作为变量名字 4尽量使用简洁方便理解的名字

字符串

字符串是Python中最常见的数据类型，用(’’ " “)单引号or双引号来创建字符串下面举例一些简单的字符串操作(首字母大小写，删除空白)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


name = "tarkyn abc"
print(name.title())
---
Tarkyn Abc

name.title()  首字母全大写
name.lower()  首字母全小写
name.rstrip() 删除左空白  
name.lstrip() 删除右空白
name.strip()  剔除字符串两边空白

制表符 \t 换行符\n

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


print("python")
print("\tpython")
---
python
    python    

print("python")
print("\npython\njava\nc")
---
python
python
java
c

在字符串中使用变量

1
2
3
4
5
6


first_name = "tarkyn"
last_name = "abc"
message = f"hello, {first_name}{last_name}"
print(message.title())
---
Hello, Tarkynabc

f是字符串format，python通过花括号内的变量替换成字符串的格式 f是python3.6引入的，如果是之前的版本可能需要format()

Python数字

Python数值类型通常有以下5种 ● 整型(int) 通常称为整型或整数，是正或负的整数，没有小数点 ● 长整型(long) 无限大小的整数，整数最后一个是大写或者小写的L ● 浮点型(float) 浮点型由整数部分与小数部分组成 ● 复数(complex) 复数由实数部分和虚数部分构成 ● 布尔型(bool) 布尔型是整数的子类型，布尔值有两个取值 True和False，分别对应整型的1和0

Python中可以执行 + - * / 运算

1
2
3
4
5
6


1/2  #传统除
1//2 #地板除

number = 100_000_000  #可以使用下划线将数字分类，清晰易读

x,y,z = 1,2,3         #可以同时给多个变量命名 

列表简介

序列是Python中基本的数字结构，序列中每个元素都有一个数字表示他的位置or索引，第一个是0第二个是1 序列中开始都是0 列表是Python中常见的数据类型，和字符串一样，列表索引从0开始

1
2
3


list = ["a","b","c","d"]
list2 = [1, 2, 3, 4, 5]
print(list[0])

更新列表

1
2
3
4
5
6
7
8


list = []
list.append('google')  # append()添加一个元素到列表末尾 
list.append('baidu')
list[1] = "Bing"
list.insert(2,'yahu')  # insert()在列表任何位置插入新元素
print(list)
---
['google','Bing','yahu']

删除列表

如果要从列表中删除一个元素并且不在用任何方式使用它就用del(),如果删除了元素之后还要使用那就用pop()

1
2
3
4
5
6
7


list1 = ['1988','2000','2010','2020']
del list1[0]      # 如果知道要删除元素在列表中的位置，可以用del()

fruit = ['apple','banana','pear']
pop_fruit = fruit.pop()  # pop()删除列表末尾的值，保存在另一个值中继续使用，也叫弹出
prtin(fruit)             # pop()可以弹出列表中任意位置的元素，在()中指定索引即可 
['apple','banana']

组织列表

Python中用sort()可以对列表进行一个排序,假设有一个汽车列表，我要进行字母排序 sort()方法永久性地修改列表元素的排序顺序，再也无法恢复原来的列表顺序

1
2
3
4
5


cars = ['bmw','audi','toyota','subaru']
cars.sort()     # 向sort传递参数reverse=True就会反向排序列表
print(cars)
---
['audi','bmw','subaru','toyota']

要保留元素原来的排列顺序，同时用特定的顺序展示，可以用函数sorted() sorted()可以让元素按照特定顺序展示，同时不影响他们在列表中的排列顺序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


cars = ['bmw','audi','toyota','subaru']
print(cars)
cars = ['bmw','audi','toyota','subaru']  #也可以向函数sorted()传递参数 reverse=True反向临时排序
print(sorted(cars))
cars = ['bmw','audi','toyota','subaru']
print(cars)
---
['bmw', 'audi', 'toyota', 'subaru']
['audi', 'bmw', 'subaru', 'toyota']
['bmw', 'audi', 'toyota', 'subaru']

要反转列表元素的排列顺序，可以使用方法reverse()

1
2
3
4
5


cars = ['bmw','audi','toyota','subaru']
cars.reverse()    #注意reverse()不是按字母顺序排序，而是反转列表的顺序，也是永久性的，可以再次反转
print(cars)
---
['subaru','toyota','audi','bmw']

使用函数len()可以快速知道列表的长度 len(cars) Python计算元素数量从1开始所以不会有问题

操作列表

常常需要遍历列表的所有元素，对每个元素进行操作

for循环遍历列表

用for循环打印水果名单中的所有水果,这行代码从列表fruits中提取一个元素然后和fruit关联 ```python fruits = ['apple','banana','pear','orange'] for fruit in fruits: print (fruit) --- apple banana pear orange ```

1
2
3
4
5
6
7
8


fruits = ['apple','banana','pear','orange']
for fruit in fruits:
    print (f"I what to eat{fruit}")
---
I what to eat apple
I what to eat banana
I what to eat pear
I what to eat orange

for循环需要注意缩进和冒号

创建数值列表

1
2
3
4
5
6
7
8


list(range(6))
list(range(0,6))
list(range(0,6,2))

列表解析

abc = [b**2 for b in range(1,11)]  #用多行代码比较复杂繁琐就需要列表解析
print(abc)

数字列表简单的统计计算

1
2
3
4


digits = [1,2,3,4,5,6,7,8,9,0]
min(digits) # 最小值
max(digits) # 最大值
sum(digits) # 求和

列表切片

打印列表的2、3、4个(索引就是1、2、3) 头尾减一就可以了，不会搞错

1
2
3


fruits = ['apple','banana','pear','orange']
print(players[1:3])    #从索引1-3
print(players[1:3:2])  #从索引1-3每隔2个元素提取一个  默认为1

遍历切片，其实就是用for循环打印一段话加上列表的切片

1
2
3
4


fruits = ['apple','banana','pear','orange']
print("my favourite fruit is:")
for fruit in fruits[0:3]:
    print(fruit)

复制列表

1
2
3
4
5
6


my_foods = ['pizza','carrot','cake']
friend_foods = my_foods[:]    #只需要在复制的列表后面加一个切片并省略启示和终止索引就可以了
---
复制列表使用切片 friend_foods = my_foods[:]
如果使用friend_foods = my_foods
就会有一个问题，这两个永远都变成一样的了，后续不能单独修改某一个列表了  

元组

需要创建一系列不可修改的元素，元组可以满足这种需求，Python将不能修改的值称为~不可变的~,不可变的列表被称为元组

1
2
3


dimensions = (200,50)
for dimesion in dimensions:
    print(dimesion)

虽然不能修改元组的元素，但是可以给元组重新赋值 dimensions = (200,50)

dimensions = (400,100) 相比于列表，元组是更加简单的数据结构。如果要存储一些值在生命周期内不会发生改变就可以用元组

Python条件语句

在python中if语句可以检查当前程序的状态，并采取相应的措施

1
2
3
4
5
6


cars = ['audi','bmw','toyota','subaru']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title()) 

这个案例中如果遇到是bmw就全大写，不是bmw的就首字母大写

简单的条件测试

1
2
3
4
5
6
7
8
9


car = 'bmw'     #检查是否相等
car == 'audi'

car = 'Audi'    #检查是否忽略大小写
car = 'audi'

requested_topping = "mushrooms"    #检查是否不相等  要判断两个值是否不相等，可以用(!=)
if requested_topping != 'anchovies':
    print("hello the anchovies!") 

数值比较

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


age = 19   
age == 18   false
age < 18    false
age > 18    true
也可以比较多个条件  and必须要两个条件都满足，or只需要一个条件满足就可以了
age_0 = 20
age_1 = 21
age_0 > 19 and age_1 > 19  #改善可读性可以把测试代码放在圆括号中(age_0 > 10) and (age_1 <= 21)

age_0 > 19 or age_1 > 19

布尔式表达

布尔式通常用于记录条件，比如游戏正在运行中，是否可以编辑。

1
2


game_active = true
can_edit = false

Python条件语句

Python程序语言指定非0和非空 (null)的值为true，0或者 null为false

Python中 if 语句常见的形式

1
2
3
4
5


age = 18
if age < 18:
    执行语句...
else age >=18:
    执行语句...

1
2
3
4
5
6


if age < 18:
    执行语句...
elif age = 18:
    执行语句...
else age > 18:
    执行语句...

1
2
3
4
5
6
7
8


if age < 18:
    执行语句...
elif age == 25:
    执行语句...
elif age >25<45: 
    执行语句...
elif：age >=65:
    执行语句...

Python 字典

字典是另一种可变容器模型，且可以储存任意类型对象

字典的每个键值key：value 用：分割，整个字典包括在花括号{}中

1

b = {key1 : value1 , key2 : value2}

键是必须不可变的，值可以取任何数据类型，数，字符串，列表，乃至字典

1
2


dic1 = { 'abc': 123 }
dic2 = {'abc': 456 , 66 : 30 }

字典的修改更新和删除

1
2
3
4


dic1 = {'name':'zhangsan','age':18,'class':'first' }

dic1['age'] = 19  #更新
dic1['school'] = 'US'  #添加

1
2
3
4
5


dic1 = {'name':'zhangsan','age':18,'class':'first' }

del dic1['name']  # 删除键是'name'的条目
dic1.clear()      # 清空字典的所有条目
del dic1          # 删除字典

删除字典后 Print 会引发一个报错，因为del之后字典就不存在了

如果指定的值有可能不存在可以用 get() ，如果字典中没有指定的值会返回 None

遍历字典

用 for循环遍历字典，可申明两个变量，用于储存键和值，用 items() 返回一个键值列表

1
2
3
4
5
6
7


favorite_languages = {
    'jen': 'python',
    'zs': 'c++',
    'ls': 'java',
}
for name,language in favorite_languages.items():
    print(f"{name} favorite language is {language}")

遍历字典中所有的键用 keys() ，遍历字典中所有的值用 values() ，这个做法提取字典中所有的值，而没有考虑重复的问题，要提取集合中独一无二的用 set()

1
2
3
4
5


for name in favorite_language.keys():       # keys()
    
for language in favorite_language.values(): # values()

for language in set(favorite_language.values()):  # set()

字典列表嵌套

将一系列字典储存在列表中，或将列表作为值储存在字典中，称为嵌套。其实就是套中套

在字典中储存列表，在字典中储存字典

1
2
3
4
5
6


for alines_number in range(30):
    new_alines = {'color': 'red','points':'5','speed':'10'}
    alines.append(new_alines)

for alines in alines[:30]:
    print(alines)

1
2
3
4


computer = {
    'cpu': 3500x
    'ram': ['8g_1', '8g_2']
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


users = {
    zhangsan:{
        'first': 'zhang'
        'last': 'san'
        'location': 'CA'
        },
    lisi:{
        'first': 'li'
        'last': 'si'
        'location': 'JP'
        },
}

用户输入和While 循环

input函数

函数input()接受一个参数，在用input函数是要指定清楚的提示，准确的让用户输入信息

1
2


name = input('please enter your name:')
print(f"\nhello,{name}")

int()获取数值输入

用input输入一个数字，python会把它当成字符串，所以要用函数int（）将数的字符串转换为数值表示

1
2
3
4
5


>>> age = input("how old are you?")
how old are you? 21
>>> age = int(age)
>>> age >= 18
True 

求模运算符

求模运算符%，将两个数相除并返回余数，可以用这个来判断奇数还是偶数

1
2
3
4
5
6


>>> 4 % 3 
1
>>> 6 % 3
0
>>> 7 % 3
1

while循环

for循环针对集合中的每个元素都执行一次，而while循环是不断运行，知道条件不满足为止

1
2
3
4


number = 1
while number <= 5:
    print(number)
    number+= 1

让用户选择什么时候退出，我们可以直接在while循环中定义一个退出值，当用户输入名字之后只要没有输入quit就可以一直输入名字

1
2
3
4
5
6
7
8
9


a = "你的名字是： "                   #前面创建一些个变量
b = "你退出了"
cc = ""
while cc !="quit":                   #while条件 只要cc不是quit就不停了
    cc = input("请输入你的名字：")
    if cc !="quit":
        print(cc)                    #变量cc不是quit就打印刚刚输入的名字，然后回头继续执行while，因为没有结束的条件
    else:
        print(b)                     #变量cc是quit了，就打印出来b了，然后while循环也停止了

使用标志，break，continue来控制循环

break立即退出循环，python循环中都可以使用break来退出循环

1
2
3
4
5
6
7


pd = True                       #创建一个标志 pd 当pd为True的时候循环正常运行
while pd:
    message = input()
    if message == 'quit':       #当输入的值为quit的时候，标志pd 变成False，程序就停止了 
        pd = False              #也可以把这一行直接改成break，这样当message为quit的时候就直接退出循环
    else:
        print(message)

continue更像是弹出当前的命令从头去再次执行，并不是直接退出

1
2
3
4
5
6


nb = 0
while nb <= 10:          #nb小于等于10就执行while循环
    nb += 1              
    if nb % 2 == 0:      #如果nb能被2整除那就弹出从头开始，不继续下面的指令了
        continue
    print(nb)

用while循环中处理列表和字典

for循环是一种遍历列表的有效方式，但不适合用for来修改列表，这样会让python难以跟踪里面的元素，while循环可以在遍历的同时进行修改

1
2
3
4
5
6
7
8


unconfirmed_users = ['a','b','c']             #没有验证的用户
confirmed_users = []                          #创建一个验证用户的列表

while unconfirmed_users:                      #这里while就会去循环列表中的用户
    current_users = unconfirmed_users.pop()   #把循环过的用户弹出到验证用户的列表中
    confirmed_users.append(current_users)     #把验证列表中的用户加入到验证用户的列表中

print(confirmed_users)    

用while循环去删除列表中的元素

1
2
3
4
5


pets = ['cat','cat','dog','rabbit','fish']
print(pets)
while 'cat' in pets:         #如果cat在这个宠物列表中
    pets.remove('cat')       #那就从这个宠物列表中移除
print(pets)

函数

定义函数

1
2
3
4


def hello(user_name):                        #用def告诉python我要定义一个函数
    print(f"hello, {user_name.title()}!")    # ：后面的所有缩进行就变成了函数体

hello('tarkyn')                              #最后可以直接使用函数

变量username是一个形参，值tarkyn是一个实参

设置默认值

1
2
3
4
5


def describe_pet(pet_name, animal_type="dog"):
# 编写函数时，可以给给一个形参默认值
print(f"my {animal_type}'s name is {pet_name.title()}.")

describe_pet(pet_name="阿黄")

返回值

函数并非总是直接输出，函数返回的值都称为返回值,可以用return语句将值返回到调用函数的代码行

1
2
3
4
5


def get_name(first_name, last_name):
    full_name = f"{first_name} {last_name}"
    return full_name.title()
name = get_name('Jinqi','Tao')
print(name)

可选的实参

选择一个额外的选项，可以让需要的人输入

1
2
3
4
5
6
7
8
9


def get_name(first_name, last_name, middlea_name=''):
    if middlea_name:
        full_name = f"{first_name} {middlea_name} {last_name}"
    else:
        full_name = f"{first_name} {last_name}"
    return full_name.title()

name = get_name('Jinqi','Tao')
print(name)

返回字典

1
2
3
4
5
6
7


def build_person(first_name, last_name, age=None):
    person = {'first':first_name,'last':last_name}
    if age:
        person['age']=age
    return person
a_person = build_person('tao','jinqi',age=20)
print(a_person)

传递列表

1
2
3
4
5
6
7


def greet_users(names):
    for name in names:
        msg = f"hello, {name.title()}"
        print(msg)

username = ['a','b','c']
greet_users(username)

传递任意数量的实参

1
2
3
4
5


def make_pizza(size,*toppings):   # 形参名 *topping 中的 * 让python创建一个topping的空元组
    print(size,toppings)

make_pizza(16,'a')
make_pizza(20,'a','b','c')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def profile(first, last, **user_info):
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = profile('tao','jinqi',
                       location='shanghai',
                       gender= 'male'
                       )
print(user_profile)

将函数保存在模块中

pizza.py，一个单独的pizza模块

1
2
3


import pizza            # 导入这个函数模块

pizza.make_pizza(20,'a','b')

1
2
3


import pizza as pz      # 可以用 as 给函数指定别名

pz.make_pizza(20,'a','b')

1

from pizza import pizza_1, pizza_2    # 导入模块中的特定函数

1

from pizza import *       # 导入模块中的所有函数