python速记

前言：

记录一下自己自学python的过程，或显幼稚简单、并不完整，依需求而记，但本意是以此激励自己学习，以免半途而废，学无所成

方便下次忘记时快速查询

Main

制表符、换行符

\t : 制表符 \n ：换行符

1
2
3
4
print("aaaaa\nbbbbb\ncccccc")
aaaaa
bbbbb
ccccc
1
2
3
4
print("aaaaa\n\tbbbbb\n\tccccc")
aaaaa
	bbbbb
	ccccc

算法

Python使用两个乘号表示乘方（次方）运算

1
2
3
4
a = 10 ** 2
print(a)

a = 100

求模运算符

求模运算符（%）是一个很有用的工具，它将两个数相除并返回余数：

1
2
>>> 4 % 3
1

列表

列表索引从0 而不是1 开始（和c语言类似）

但通过将索引指定为-1，可让Python返回最后一个列表元素（-2、-3、-4……）

1
2
3
bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles[-1])
//输出specialized

增删改

修改列表元素

通过指定要修改元素的索引

1
2
3
4
5
6
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles[0] = 'ducati'
print(motorcycles)
['honda', 'yamaha', 'suzuki']
['ducati', 'yamaha', 'suzuki']

添加元素append()、insert()

列表末尾添加元素append()

通过方法append()将元素’ducati’添加到了列表末尾

1
2
3
4
5
6
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
motorcycles.append('ducati')
print(motorcycles)
['honda', 'yamaha', 'suzuki']
['honda', 'yamaha', 'suzuki', 'ducati']

列表中插入元素insert()

1
2
3
4
5
motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, 'ducati')
print(motorcycles)
['ducati', 'honda', 'yamaha', 'suzuki']
//方法insert()在索引0处添加空间，并将值'ducati'存储到这个地方

删除元素del、pop()、remove()

**del:**如果知道要删除的元素在列表中的位置，可使用del语句。

1
2
3
4
5
6
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
del motorcycles[0]
print(motorcycles)
['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']

**pop():**当你要将元素从列表中删除，并接着使用它的值，方法pop()可删除列表末尾的元素

1
2
3
4
5
6
7
8
motorcycles = ['honda', 'yamaha', 'suzuki']
print(motorcycles)
popped_motorcycle = motorcycles.pop()#删除了最后的suzuki,并将其存在popped_motorcycle
print(motorcycles)
print(popped_motorcycle)
['honda', 'yamaha', 'suzuki']
['honda', 'yamaha']
suzuki

当然pop()也可以指定位置删除

1
first_owned = motorcycles.pop(0)#指定0索引位置

**remove():**不知道要从列表中删除的值所处的位置,只知道要删除的元素的值

1
2
3
4
5
6
motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
print(motorcycles)
motorcycles.remove('ducati')  #删除指定值ducati
print(motorcycles)
['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']

切片

列表的部分

1
2
3
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print(players[0:3])
['charles', 'martina', 'michael']
1
2
3
print(players[1:4])   #提取第2到4的元素
print(players[:4])    #提取从开头到4的元素
print(players[1:])    #提取第2到结尾的元素

遍历切片

选取列表的一部分进行遍历

1
2
3
4
5
for player in players[:3]:
    print(player.title())
Charles
Martina
Michael

复制列表和切片

1
2
my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]  #复制列表全部元素

元组

即不可变的列表

定义

不同于列表的**[]，元组定义使用的是()**

例如：

1
2
3
4
dimensions = (200, 50)
print(dimensions[0])

200

当尝试修改元组时，就会出现报错

1
dimensions[0] = 250

修改

当然还有一种方法可以修改元组

就是重新定义整个元组，覆盖掉之前的元组

1
2
3
4
5
6
dimensions = (200, 50)

dimensions = (400, 100)
print(dimensions[0])

400

循环

for循环

for i in range（n）

在Python中，for i in range(n)是一个循环语句，用于重复执行指定的代码块n次。range(n)是一个内置函数，用于生成从0到n-1的整数序列，这个序列可以被用来控制循环次数。

在循环的每一次迭代中，变量i会被赋值为当前迭代的整数值。可以利用这个变量在循环体内执行特定操作，比如打印当前迭代的值，或者使用它来访问列表或数组中的元素。

例如，下面的代码将会打印0到4的数字序列：

1
2
for i in range(5):
    print(i)

输出结果：

1
2
3
4
1
2
3
4

需要注意的是，range()函数的结束值是不包含在范围内的。因此，如果想循环5次，需要传递参数range(5)，而不是range(6)。

1
2
3
4
5
6
def reverse(test_set):
    n=len(test_set)
    reverse_test_set=[]
    for i in range(n):
        reverse_test_set.append(test_set[n-i-1])
    return reverse_test_set

while循环

1
2
3
4
current_number = 1
while current_number <= 5:
print(current_number)
current_number += 1

列表解析

在列表中嵌入一个for循环

以更少的代码来达到相同的效果

1
2
squares = [value**2 for value in range(1,11)]
print(squares)

这里value**2是表达式（计算式），for value in range(1,11)就是for循环

上面的代码执行结果就是：

1
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

if判断

in 和 not in

检查特定值是否包含在列表中

1
2
3
4
5
>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']
>>> 'mushrooms' in requested_toppings
True
>>> 'pepperoni' in requested_toppings
False
1
2
3
4
banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
 if user not in banned_users:
print(user.title() + ", you can post a response if you wish.")

if-elif-else 结构

1
2
3
4
5
6
7
if age < 4:
print("Your admission cost is $0.")
 elif age < 18:
print("Your admission cost is $5.")
 else:
print("Your admission cost is $10.")

字典

采用字符{}，字典是一系列键—值对。每个键都与一个值相关联

例：

1
alien_0 = {'color': 'green'}

在这个字典中，字符串’color’是一个键，与之相关联的值为’green’。

要输出值时采用[]

1
print(alien_0['color'])

添加键值对

要添加键值对的时候，类似c语言直接赋值就好了（空字典可以赋值=，而空列表就不行）

1
alien_0['y_position'] = 25

修改字典值

指定要修改的键，再次赋值，值就会被新的覆盖，也就达到了修改的效果

1
2
3
4
alien_0 = {'color': 'green'}
print("The alien is " + alien_0['color'] + ".")
alien_0['color'] = 'yellow'
print("The alien is now " + alien_0['color'] + ".")

删除键—值对

类似于列表的删除元素，采用del()函数就可以了

1
2
3
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
del alien_0['points']

遍历字典

Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系。

1
2
3
4
5
6
7
8
user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
 for key, value in user_0.items():
 print("\nKey: " + key)
 print("Value: " + value)

可声明两个变量，用于存储键—值对中的键和值。这里声明了key，value。当然对于这两个变量，可使用任何名称。例如：

1
for k, v in user_0.items()

返回：

1
2
3
4
5
6
Key: last
Value: fermi
Key: first
Value: enrico
Key: username
Value: efermi

关于这里的item()

在Python中，items()是一个字典(dict)的方法，用于返回字典的所有键值对作为一个可迭代对象。

具体来说，items()方法返回一个包含字典中所有键值对的视图对象。每个键值对都表示为一个元组，其中第一个元素是键，第二个元素是对应的值。这个视图对象可以用于迭代字典中的所有键值对，也可以通过转换为列表或其他可迭代对象来使用。

上面的示例中，我们首先调用items()方法获取字典user_0的所有键值对，并将结果存储在items变量中。然后，我们使用for循环迭代items，并使用解构赋值将每个键值对的键赋值给key，值赋值给value，然后将它们打印出来。

遍历所有键keys()

遍历字典时，会默认遍历所有的键，因此，如果将代码中的for name in favorite_
languages.keys():替换为for name in favorite_languages:，输出也不变。

1
2
3
4
5
6
7
8
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
 for name in favorite_languages.keys():
print(name.title())

结果

1
2
3
4
Jen
Sarah
Phil
Edward

keys()并非只能用于遍历，用于if语句

1
if 'erin' not in favorite_languages.keys():

遍历所有值values()

1
2
for language in favorite_languages.values():
print(language.title())

按顺序遍历sort()

更多方法看函数那块

1
2
3
4
5
6
7
8
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in sorted(favorite_languages.keys()):
print(name.title() + ", thank you for taking the poll.")

嵌套

列表套字典

1
2
3
4
alien_0 = {'color': 'green', 'points': 5}
alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
 aliens = [alien_0, alien_1, alien_2]

字典套字典

1
2
3
4
5
6
7
8
9
10
11
12
users = {
'aeinstein': {
'first': 'albert',
'last': 'einstein',
'location': 'princeton',
},
'mcurie': {
'first': 'marie',
'last': 'curie',
'location': 'paris',
},
}

用户输出input()

1
2
message = input("Tell me something, and I will repeat it back to you: ")
print(message)

break与continue

break语句用于控制程序流程，可使用它来控制哪些代码行将执行，哪些代码行不执
行，从而让程序按你的要求执行你要执行的代码。

1
2
3
4
5
6
prompt = "\nPlease enter the name of a city you have visited:"
prompt += "\n(Enter 'quit' when you are finished.) "
 while True:
city = input(prompt)
if city == 'quit':
break

要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句，它
不像break语句那样不再执行余下的代码并退出整个循环。

1
2
3
4
5
6
current_number = 0
while current_number < 10:
 current_number += 1
if current_number % 2 == 0:
continue
print(current_number)

函数

注意：给形参指定默认值时，等号两边不要有空格

正确示例：

1
def function_name(parameter_0, parameter_1='default value')

定义函数def

1
2
3
4
def greet_user():
 """显示简单的问候语"""
 print("Hello!")
greet_user()

向函数传递信息(test)

通过在这里添加username，就可让函数接受你给username指定的任何值。现在，这个函数要求你调用它时给username指定一
个值。

1
2
3
4
def greet_user(username):
 """显示简单的问候语"""
 print("Hello, " + username.title() + "!")
greet_user('jesse')

在函数greet_user()的定义中，变量username是一个形参——函数完成其工作所需的一项信
息。在代码greet_user(‘jesse’)中，值’jesse’是一个实参。实参是调用函数时传递给函数的信
息。（还是直接看代码比较容易理解）

传递实参

位置实参

你调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，
最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。

说白了就是按照顺序传参，看代码理解就好了

1
2
3
4
5
def describe_pet(animal_type, pet_name):
 """显示宠物的信息"""
 print("\nI have a " + animal_type + ".")
 print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet('hamster', 'harry')

按照顺序，这里hamster对应animal_type,harry对应pet_name。

关键字实参

1
2
3
4
5
def describe_pet(animal_type, pet_name):
"""显示宠物的信息"""
 print("\nI have a " + animal_type + ".")
 print("My " + animal_type + "'s name is " + pet_name.title() + ".")
describe_pet(animal_type='hamster', pet_name='harry')

调用这个函数时，我们向Python明确地指出了各个实参对应的形参。看到这个函数调用时，Python知道应该将实参’hamster’和’harry’分别存储在形参animal_type和pet_name中。

默认值

1
2
3
4
def describe_pet(pet_name, animal_type='dog'):
 """显示宠物的信息"""
 print("\nI have a " + animal_type + ".")
 print("My " + animal_type + "'s name is " + pet_name.title() + ".")

默认值为dog

返回值return

1
2
3
4
def get_formatted_name(first_name, last_name):
"""返回整洁的姓名"""
  full_name = first_name + ' ' + last_name
  return full_name.title()

同时也能返回字典

1
2
3
4
5
6
def build_person(first_name, last_name):
"""返回一个字典，其中包含有关一个人的信息"""
 person = {'first': first_name, 'last': last_name}
 return person
musician = build_person('jimi', 'hendrix')
 print(musician)

再进一步应用

第一个函数将负责处理打印设计的工作，而第二个将概述打印了哪些设计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def print_models(unprinted_designs, completed_models):
  """
  模拟打印每个设计，直到没有未打印的设计为止
  打印每个设计后，都将其移到列表completed_models中
  """
  while unprinted_designs:
    current_design = unprinted_designs.pop()
  # 模拟根据设计制作3D打印模型的过程
    print("Printing model: " + current_design)
    completed_models.append(current_design)
def show_completed_models(completed_models):
  """显示打印好的所有模型"""
  print("\nThe following models have been printed:")
  for completed_model in completed_models:
    print(completed_model)
unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']
completed_models = []
print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)

传递任意数量的实参*

1
2
3
4
5
def make_pizza(*toppings):
"""打印顾客点的所有配料"""
  print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。函数体内的print语句通过生成输出来证明Python能够处理使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，Python将实参封装到一个元组中，即便函数只收到一个值也如此：

1
2
('pepperoni',)
('mushrooms', 'green peppers', 'extra cheese')

使用任意数量的关键字实参**

函数build_profile()接受名和姓，同时还接受任意数量的关键字实参：

1
2
3
4
5
6
7
8
9
10
11
12
def build_profile(first, last, **user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切"""
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile
user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                              field='physics')
print(user_profile)

函数存储在模块中

导入整个模块import

1
import pizza

pizza是一个已有的模块，然后就能调用该模块里的函数了

导入特定的函数

1
2
3
from module_name import function_name
from module_name import function_0, function_1, function_2
from pizza import make_pizza

导入模块中的所有函数

1
from pizza import *

然而，使用并非自己编写的大型模块时，最好不要采用这种导入方法：如果模块中有函数的名称与你的项目中使用的名称相
同，可能导致意想不到的结果

给函数、模块指定别名as

给函数make_pizza()指定了别名mp()

1
from pizza import make_pizza as mp

如给模块pizza指定别名p

1
import pizza as p

类

方法__init__()

类中的函数称为方法；__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线。

创建和使用类

创建 类：

1
2
3
4
5
6
7
8
9
10
11
12
class Dog():
 """一次模拟小狗的简单尝试"""
 def __init__(self, name, age):
"""初始化属性name和age"""
   self.name = name
   self.age = age
 def sit(self):
"""模拟小狗被命令时蹲下"""
   print(self.name.title() + " is now sitting.")
def roll_over(self):
"""模拟小狗被命令时打滚"""
   print(self.name.title() + " rolled over!")

我们将方法__init__()定义成了包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。

我们将通过实参向Dog()传递名字和年龄；self会自动传递，因此我们不需要传递它。每当我们根据Dog类创建实例时，都只需给最
后两个形参（name和age）提供值。

创建实例

我们通常可以认为首字母大写的名称（如Dog）指的是类，而小写的名称（如my_dog）指的是根据类创建的实例。

1
2
3
my_dog = Dog('willie', 6)
 print("My dog's name is " + my_dog.name.title() + ".")
 print("My dog is " + str(my_dog.age) + " years old.")

给属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。

1
2
3
4
5
6
7
class Car():
def __init__(self, make, model, year):
"""初始化描述汽车的属性"""
  self.make = make
  self.model = model
  self.year = year
  self.odometer_reading = 0

继承

继承父类的方法

创建子类的实例时，Python首先需要完成的任务是给父类的所有属性赋值。

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
class Car():
"""一次模拟汽车的简单尝试"""
 def __init__(self, make, model, year):
   self.make = make
   self.model = model
   self.year = year
   self.odometer_reading = 0
 def get_descriptive_name(self):
   long_name = str(self.year) + ' ' + self.make + ' ' + self.model
   return long_name.title()
 def read_odometer(self):
   print("This car has " + str(self.odometer_reading) + " miles on it.")
 def update_odometer(self, mileage):
   if mileage >= self.odometer_reading:
      self.odometer_reading = mileage
   else:
      print("You can't roll back an odometer!")
 def increment_odometer(self, miles):
   self.odometer_reading += miles
class ElectricCar(Car):
"""电动汽车的独特之处"""
 def __init__(self, make, model, year):
"""初始化父类的属性"""
   super().__init__(make, model, year)
   my_tesla = ElectricCar('tesla', 'model s', 2016)
   print(my_tesla.get_descriptive_name())

class ElectricCar(Car): uper()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让Python调用
ElectricCar的父类的方法__init__()，让ElectricCar实例包含父类的所有属性。

这样就能使用父类的属性和方法了

子类定义属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Car():
--snip--
class ElectricCar(Car):
"""Represent aspects of a car, specific to electric vehicles."""
  def __init__(self, make, model, year):
"""
电动汽车的独特之处
初始化父类的属性，再初始化电动汽车特有的属性
"""
     super().__init__(make, model, year)
     self.battery_size = 70
   def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
     print("This car has a " + str(self.battery_size) + "-kWh battery.")
     my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

相比父类，多了属性self.battery_size和方法describe_battery(self):

在子类中重写父类的方法

直接在子类中写一个方法名称相同就可以覆盖了

1
2
3
4
5
def ElectricCar(Car):
--snip--
def fill_gas_tank():
  """电动汽车没有油箱"""
  print("This car doesn't need a gas tank!")

导入类

假设在car.py内有Car和ElectricCar类，你想要在111.py文件同时导入这两个类，只需：

1
from car import Car,ElectricCar

当然，如果你想导入整个模块

1
import car

或者导入模块的所有类

1
from module_name import *

文件

读取写入文件

1
2
3
filename = 'programming.txt'
with open(filename, 'w') as file_object:
     file_object.write("I love programming.")

关键字with在不再需要访问文件后将其关闭。也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存
在bug，导致close()语句未执行，文件将不会关闭。

可指定读取模式（’r’）

写入模式（’w’）会覆盖原有内容，多用于写入空文件

附加模式（’a’）或让你能够读取和写入文件的模式（’r+’） 用于添加文件内容

逐行读取for line in file_object:

1
2
3
4
filename = 'pi_digits.txt'
  with open(filename) as file_object:
  for line in file_object:
print(line)

文件路径

在Linux和OS X中:

1
with open('text_files/filename.txt') as file_object:

Windows系统中:

1
with open('text_files\filename.txt') as file_object:

当然也能采用绝对路径：

1
2
file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt'
with open(file_path) as file_object:

存储数据

对于用户生成的数据，使用json保存它们大有裨益，因为如果不以某种方式进行存储，等程
序停止运行时用户的信息将丢失。

json.dump()和json.load()

例如使用json.dump()来存储数字列表：

1
2
3
4
5
import json
numbers = [2, 3, 5, 7, 11, 13]
filename = 'numbers.json'
with open(filename, 'w') as f_obj:
 json.dump(numbers, f_obj)

使用json.load()将这个列表读取到内存中：

1
2
3
4
5
import json
filename = 'numbers.json'
with open(filename) as f_obj:
numbers = json.load(f_obj)
  print(numbers)

实际运用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import json
# 如果以前存储了用户名，就加载它
# 否则，就提示用户输入用户名并存储它
filename = 'username.json'
try:
  with open(filename) as f_obj:
  username = json.load(f_obj)
except FileNotFoundError:
  username = input("What is your name? ")
  with open(filename, 'w') as f_obj:
  json.dump(username, f_obj)
  print("We'll remember you when you come back, " + username + "!")
else:
  print("Welcome back, " + username + "!")

我们尝试打开文件username.json。如果这个文件存在，就将其中的用户名读取到内存中，再执行else代码块，即打印一条欢迎用户回来的消息。用户首次运行这个程序时，文件username.json不存在，将引发FileNotFoundError异常，因此Python将执行except代码块：提示用户输入其用户名，再使用json.dump()存储该用户名，并打印一句问候语。

函数

修改字符输出大小写：title() 、upper()、lower()

title() : 以首字母大写方式显示每个单词

upper() : 全转化为大写

lower() : 全转化为小写

1
2
3
4
hey = "good day"
print('a=' + hey.title())
print('b=' + hey.upper())
print('c=' + hey.lower())

可以看到输出：

a=Good Day
b=GOOD DAY
c=good day

删除空白lstrip()、rstrip()、strip()

lstrip() :删除开头空白

rstrip():删除末尾空白

strip():删除两端的空白

1
2
3
4
5
6
7
8
hey = " good day "
print('a=' + hey.lstrip() + '1')
print('b=' + hey.rstrip() + '1')
print('c=' + hey.strip() + '1')

a=good day 1
b= good day1
c=good day1

转字符str()

将非字符串值表示为字符串：

1
2
3
4
5
hey = 111
hey_1 = "222" + str(hey)  #不加str则会把111当成int类型，从而报错
print(hey_1)

222111

转数值int()

1
2
3
4
height = input("How tall are you, in inches? ")
height = int(height)
if height >= 36:
print("\nYou're tall enough to ride!")

对列表排序sort()、sorted()、reverse()

sort()：对列表进行永久性排序

sorted()：对列表进行临时排序

reverse()：反转列表元素的排列顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
#sort()
#这里对列表元素排列顺序的修改是永久性的：
#按字母顺序排列
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
print(cars)
['audi', 'bmw', 'subaru', 'toyota']
#按与字母顺序相反的顺序排列列表元素，为此，只需向sort()方法传递参数
reverse=True。下面的示例将汽车列表按与字母顺序相反的顺序排列：
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort(reverse=True)
print(cars)
['toyota', 'subaru', 'bmw', 'audi']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#sorted()
#临时排序，其他和sort()用法差不多
cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list:")
print(cars)
print("\nHere is the sorted list:")
print(sorted(cars))  #由于sorted()只能临时排序，故只能套进print用
print("\nHere is the original list again:")
print(cars)
我们首先按原始顺序打印列表，再按字母顺序显示该列表。以特定顺序显示
列表后，我们进行核实，确认列表元素的排列顺序与以前相同。
Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']
Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']
Here is the original list again:
['bmw', 'audi', 'toyota', 'subaru']
1
2
3
4
5
6
7
8
9
#reverse()
#反转列表元素的排列顺序,也就是倒着输出
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)

['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']

确定列表的长度len()

1
2
3
cars = ['bmw', 'audi', 'toyota', 'subaru']
len(cars)
4

注：Python计算列表元素数时从1开始，而不是0

range()生成数字

1
2
3
4
5
6
for value in range(1,5):
print(value)
1
2
3
4

注意没有5

还可以指定步数：

1
2
3
4
5
#步长为2
even_numbers = list(range(1,11,2))
print(even_numbers)

[1, 3, 5, 7, 9，11]

list()转化为列表

1
2
3
numbers = list(range(1,6))
print(numbers)
[1, 2, 3, 4, 5]

处理数字列表min()、max()、sum()

min():找出列表最小值

max():找出列表最大值

sum():计算总和

1
2
3
4
5
6
7
>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45

切片表示法[:]

切片表示法[:]创建列表的副本

可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

1
function_name(list_name[:])

CTF笔记

保留标识符类_

根据python文档 _在python shell里保存了上一次求值的结果

所以可以通过_+”__”获取一个字符串变量 可以不断拼接绕过7个字符的限制

技能学习
#python
python速记
https://www.smal1.black/Python.html
作者
Small Black
发布于
2023年3月15日
许可协议