• python 语法回顾总结

    定义变量 + 打印输出

    price = 8.5
weight = 1
money = price * weight
print(money)


直接输出
print(520)
print(98.5)
print(3 * 1)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    if else 条件

    

import keyword

print(keyword.kwlist)

if True:
    print("True")
else:
    print("False")



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

    数字类型

    python中数字有四种类型：整数、布尔型、浮点数和复数。

    count = 100
miles = 100.0
name = "zzz"

print(count)
print(miles) 
print(name)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    多变量赋值

    a  = b = c = 1

print(a)
print(b)
print(c)

    • 1
    • 2
    • 3
    • 4
    • 5
    a, b, c = 1,2, 'zz'
print(a)
print(b)
print(c)

    • 1
    • 2
    • 3
    • 4

    标准数据类型

    Number（数字）
    String（字符串）
    List（列表）
    Tuple（元组）
    Set（集合）
    Dictionary（字典）

    三个不可变数据

    number 数字

    int float bool complex

    a, b, c, d = 20,5.5, True, 4 + 3j

print(a)
print(b)
print(c)
print(d)

print(type(a))
print(type(b))
print(type(c))
print(type(d))

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    a = 20
print(isinstance(a, int)) # True

    • 1
    • 2

    运算

    print(5 + 4) # 9 加法
print(3.3 - 1) # 2.3 # 减法
print(3 * 7) # 21 # 加法
print(2 / 4) # 0.5 # 除法
print(7 // 4) # 1 # 取mod
print(7 % 4) # 3 # 取余
print(2 ** 2) # 4 # 次方

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    string 字符串

    tuple 元组

    字符串裁剪

    str = "0123456789"


# 0 到 最后倒数第一个
print(str[0:-1]) # 01234567
print(str[0]) # 0
print(str[2:5]) # 234

print(str[2:]) # 2345678

# 字符串间隔
print(str[1:5:1])
print(str[1:5:2]) # 从index2开始 到 index4 每隔1个字符


print(str * 2) # 01234567890123456789

print("——"* 10) # ————————————————————

print('hello\nworld')
'''
hello
world
'''

print('\n') # empnty row 空行
print(r'\n') # 输出 \n




## 字符串 取字符
word = "Python"

print(word[0]) # P
print(word[-1]) # n

print(word[0],word[1],word[2]) # P y t

    • 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

    List

    t = ['a','b','c','d','e']
print(t) # 打印列表
print(t[0]) # 输出列表第一个元素
print(t[1:4]) # index1开始 到 index3
print(t * 2) # 列表 两次 扩容 ['a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']

t2 = [123,'abc']
print(t + t2) # ['a', 'b', 'c', 'd', 'e', 123, 'abc']

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    #  修改列表中元素
a = [1,2,3,4,5,6]
# print(a[0]) # 1

# a[0] = 2
# print(a[0]) # 2
# print(a) # [2, 2, 3, 4, 5, 6]

a[2:5] = [11,12,13]
print(a) # [1, 2, 11, 12, 13, 6]

a[2: 5] = []
print(a) # [1, 2, 6]



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

    append 和 del

    
l = ['a','b','c']

l.append('b')

print(l) # ['a', 'b', 'c', 'b']

l2 = ['c', 'e', 'f']
l.append(l2[0])  # ['a', 'b', 'c', 'b', 'c']
print(l)

l.append(l2) # ['a', 'b', 'c', 'b', 'c', ['c', 'e', 'f']]
print(l)

del l[0] # 删除第一个元素 ['b', 'c', 'b', 'c', ['c', 'e', 'f']]
print(l)
# del l[4] # 删除第四个元素
del l[-1] # 删除第四个元素
print(l)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    列表直接 +

    l1 = [1,2,3,4]
l2 = [3,2,3]
print(l1 + l2) # [1, 2, 3, 4, 3, 2, 3]

    • 1
    • 2
    • 3

    list嵌套

    a = [1,2,3]
b = ['1','2','3'] 
c = [a, b] # [[1, 2, 3], ['1', '2', '3']]
print(c)

print(c[0][0]) # 1

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    operator.eq 列表比较

    
import operator

a = [1,2,3]
b = ['1','2','3']
c = [1,2,3]


print(operator.eq(a,b)) # False
print(operator.eq(a,c)) # True

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    常用list命令

    sum max list len

    a = {12, 12321, 31, 12, 213, 212, 23, 3, 2, 1}
n = max(a)
print(n) # a中最大值 12321

    • 1
    • 2
    • 3
    a = {12, 12321, 31, 12, 12, 213, 212, 23, 3, 2, 1}
b = list(a)
print(a) # {12321, 2, 3, 1, 12, 212, 213, 23, 31}
print(b) # [12321, 2, 3, 1, 12, 212, 213, 23, 31]

    • 1
    • 2
    • 3
    • 4

    count（）

    a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
n = a.count(12) 
print(n) # 统计12在 a中出现次数

    • 1
    • 2
    • 3
    a = (12, 12321, 31, 12, 213, 212, 23, 3, 2, 1)
n = a.count(12)
print(n) # 统计12在 a中出现次数


    • 1
    • 2
    • 3
    • 4

    extend()

    a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = [1,2,3]
a.extend(b)
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

区别 append

```python
a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = [1,2,3]
a.append(b)
print(a) # [[12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, [1, 2, 3]]

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

    同[] 可以用+代替

    a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = [1,2,3]
a = a+b
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

    • 1
    • 2
    • 3
    • 4
    

```python
a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = (1,2,3)
a.extend(b)
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
b = {1,2,3}
a.extend(b)
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1, 1, 2, 3]

    • 1
    • 2
    • 3
    • 4

    sort

    a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
a.sort() 
print(a) # [1, 2, 3, 12, 12, 23, 31, 212, 213, 12321]

    • 1
    • 2
    • 3

    remove

    a = [1,2,3,23,212,213,12,31,12321,12]

a.remove(12) # 删除第一个12 [1, 2, 3, 23, 212, 213, 31, 12321]
print(a)

    • 1
    • 2
    • 3
    • 4

    pop

    a = [1,2,3,23,212,213,12,31,12321,12]

c = a.pop() # 尾部删除元素
print(a) # [1, 2, 3, 23, 212, 213, 12, 31, 12321]
print(c) # 12

    • 1
    • 2
    • 3
    • 4
    • 5

    insert

    
a = [1,2,3,23,212,213,12,31,12321,12]

a.insert(-1,"asd") # 在指定 的index 前面插入
print(a) # [1, 2, 3, 23, 212, 213, 12, 31, 12321, 'asd', 12]


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    reverse

    a = [1,2,3,23,212,213,12,31,12321,12]

a.reverse() # 自身反转， 前面不接参数
print(a) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]

    • 1
    • 2
    • 3
    • 4

    copy

    a = [1,2,3,23,212,213,12,31,12321,12]

b = a.copy() # 复制a
print(b) # [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]

    • 1
    • 2
    • 3
    • 4

    clear

    a = [12, 12321, 31, 12, 213, 212, 23, 3, 2, 1]
a.clear() # 清空
print(a) # []

    • 1
    • 2
    • 3

    翻转字符串

    
# 字符串分割 和 字符串连接
def reverseWord(intput):
    inputWords = input.split(" ")

    # 第一个-1 表示 初始位置 为 最后一个位置
    # 第二个参数 为空 表示 移动到末尾
    # 第三个参数 步长 表示 逆向
    inputWords = inputWords[-1::-1]
    print(inputWords)


if __name__ == "__main__":
    input = 'i love python'
    rw = reverseWord(input)
    print(rw) # ['python', 'love', 'i']

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    Tuple 元组

    元组 和 list一样 不同支出 在于 元组内的元素不可以修改
    元组 写在() 里面， 元素之间 用 , 隔开

    
tuple = ('abc',768,'runoob',70.2)
tinytuple = (123, 'nb')

print(tuple) # ('abc', 768, 'runoob', 70.2)
print(tuple[0]) # abc
print(tuple[1:3]) # (768, 'runoob')
print(tuple[2:]) # ('runoob', 70.2)
print(tuple * 2) # ('abc', 768, 'runoob', 70.2, 'abc', 768, 'runoob', 70.2)
print(tuple  + tinytuple) # ('abc', 768, 'runoob', 70.2, 123, 'nb')


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

    1、与字符串一样，元组的元素不能修改。
    2、元组也可以被索引和切片，方法一样。
    3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
    4、元组也可以使用+操作符进行拼接。

    

tuple = (1,2,3,4,5,6)

print(tuple[0]) # 1
print(tuple[1:5]) # (2, 3, 4, 5)

# 不可以修改tuple元素
# tuple(0) = 1 # error
list = [1,2,3,4,5]
list[0] = 11 # 可以修改
print(list)

t1 = ()  # 空元组
t2 = (1,)  # 一个元素，需要在元素后添加逗号
t3 = (1)
print(type(t2)) # 
print(type(t3)) # 

l1 = []
l2 = [1]
l3 = [1,]
print(type(l2))
print(type(l3))

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    元组常用命令

    tuple也可以截取中间元素

    tp1 = ('G', 'R', 1997, 2000)
tp2 = (1, 2, 3, 4, 5, 6, 7, 8)
print("tuple1[0]: ", tp1[0]) # tuple1[0]:  G
print("tuple2[1:5]: ", tp2[1:5]) # tuple2[1:5]:  (2, 3, 4, 5)


    • 1
    • 2
    • 3
    • 4
    • 5

    tuple可以合并两个

    tp1 = ('G', 'R', 1997, 2000)
tp3 = ('G', 'R', 1997, 2000)
tp2 = (1, 2, 3, 4, 5, 6, 7, 8)
tp4 = tp1 + tp2 + tp3
print(tp4) # ('G', 'R', 1997, 2000, 1, 2, 3, 4, 5, 6, 7, 8, 'G', 'R', 1997, 2000)

    • 1
    • 2
    • 3
    • 4
    • 5

    tuple 删除

    tup = ('Google', 'Runoob', 1997, 2000)

print(tup) # ('Google', 'Runoob', 1997, 2000)

del tup
print("删除后的元组 tup : ")
print(tup) # error: name 'tup' is not defined

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    

print(len((1, 2, 3))) # 3

print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

print(('Hi',) * 4) # ('Hi', 'Hi', 'Hi', 'Hi')

print(3 in (1 ,2 ,3)) # True


for x in (1, 2, 3):  # 1 2 3
    print(x, end = " ")

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

    字典

    d = {key1: value1, key2: value2, key3: value3}
    在这里插入图片描述

    值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

    tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

print(tinydict)


d = dict()
print(d) # {}
print(len(d)) # 0
print(type(d)) # 

# 通过key获取value
print(tinydict['name']) # runnoob
print(tinydict['likes']) # 123

# 修改字典值
tinydict['name'] = 213
print(tinydict['name']) # 213

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    删除

    

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

print(tinydict)
# 删除某个键值对
del tinydict['name']
print(tinydict) # {'likes': 123, 'url': 'www.runoob.com'}

# 清空 tinydict
tinydict.clear()
print(tinydict) # {}

# 删除 字典
del tinydict
# print(tinydict) # NameError: name 'tinydict' is not defined

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    键必须不可变，所以可以用数字，字符串或元组充当

    常用命令

    
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(len(tinydict)) # 3
print(str(tinydict)) # {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(tinydict.keys()) # dict_keys(['Name', 'Age', 'Class'])

for x in tinydict.keys(): # Name Age Class
    print(x, end = " ")

print()

for v in tinydict.values(): #  Runoob 7 First
    print(v, end = " ")


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    常用命令进阶

    def f():
    tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

    if ("Name" in tinydict):
        return True
    else:
        return False

if __name__ == '__main__':
    print(f()) # True


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

    get(key, 默认值)

    
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(tinydict.get("Name")) # Runoob
print(tinydict.get("name",1)) # 1

    • 1
    • 2
    • 3
    • 4
    • 5

    获取所有键值对

    tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(tinydict.items()) # dict_items([('Name', 'Runoob'), ('Age', 7), ('Class', 'First')])

    • 1
    • 2

    创建 字典对

    
d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(d)

# 获取name的value，没有的话，就返回test
c = d.get("name", "test")
print(c)
print(d)

# 获取name的value，没有的话，返回123123 同时 捏一个 key-value放入字典
b = d.setdefault("name",123123)
print(d)
print(b)

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

    添加新的键值对到字典

    d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(d)

d.update({123 : 123})
print()

    • 1
    • 2
    • 3
    • 4
    • 5

    删除 并返回 字典键值对

    d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
a = d.pop('Name')
print(a) # Runoob
print(d) # {'Age': 7, 'Class': 'First'}

    • 1
    • 2
    • 3
    • 4

    弹出字典的最后一组键值对

    d = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
a = d.popitem()
print(a) # ('Class', 'First')
print(d) # {'Age': 7, 'Class': 'First'}

    • 1
    • 2
    • 3
    • 4

    Set 集合

    通常用 {} 或者 set() 创建
    parame = {value01,value02,…}
    或者
    set(value)

    集合创建

    
b = {'apple','apple','orange','candle'}
print(b) # {'orange', 'apple', 'candle'}

print('apple' in b) # True
print(1 in b) # False

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    set创建

    

a = set('asdasdasdasdasd')
print(a) # {'d', 'a', 's'}
b = set('aaaaaaaaccc')
print(b) # {'a', 'c'}

print(a - b) # {'s', 'd'} # 差集 a有 b无
print(a | b) # {'c', 's', 'a', 'd'} # 并集
print(a & b) # {'a'}  公共交集
print(a ^ b) # {'c', 's', 'd'} a 和 b 独有

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    
s = {'123',123}

if '123' in s:
    print(True)

    • 1
    • 2
    • 3
    • 4
    • 5
    

t = {'zz','zzz','zz'}
print(t) # 重复元素 会被自动去掉 {'zzz', 'zz'}

a = set('abbbbbbbbbc') # {'c', 'b', 'a'}
b = set('bc') # {'c', 'b'}

print(a)
print(b)


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    t = {'zz','zzz','zz'}
print(t) # 重复元素 会被自动去掉 {'zzz', 'zz'}

a = set('abbbbbbbbbc') # {'c', 'b', 'a'}
b = set('bcd') # {'c', 'b'}

print(a - b) # a 和 b 的差集 {'a'}
print(a | b) # a 和 b 的并集 {'c', 'a', 'd', 'b'}
print(a & b) # a 和 b 的 交集 {'c', 'b'}
print(a ^ b) # a 和 b 的不同时 存在的元素 {'d', 'a'}


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

    添加元素 add 和 update方法

    

t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

t.add('facebook')
print(t) # {'facebook', 'Taobao', 'Google', 'Runoob'}


t.update('www') # {'Taobao', 'Runoob', 'Google', 'w', 'facebook'}
print(t)

# 添加2个
t.update((1,2))  # {1, 2, 'Taobao', 'facebook', 'Runoob', 'Google', 'w'}
print(t)

t.update([3,4,5]) # {'Taobao', 1, 2, 3, 4, 5, 'Runoob', 'Google', 'w', 'facebook'}
print(t)

# 添加 多个
t.update([88,99,10],[122312,1231231])
print(t) # {1, 'facebook', 2, 3, 4, 5, 99, 122312, 'Taobao', 10, 1231231, 'Google', 88, 'Runoob', 'w'}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    

d = {}

d['one'] = 1
d[2] = 2

print(d)
print(d['one'])
print(d[2])

tdic = {'name':'run', 'code':1, "asd":"vce"}

print(tdic.keys()) # dict_keys(['name', 'code', 'asd'])
print(tdic.values()) # dict_values(['run', 1, 'vce'])


a = dict([('R',1),('G',2),(1,1)])
print(a) # {'R': 1, 'G': 2, 1: 1}


b = {x: x**2 for x in (2, 4 , 6)} # {2: 4, 4: 16, 6: 36}
print(b)

c = dict(a=1, b=2, c = 3) # {'a': 1, 'b': 2, 'c': 3}
print(c)

    • 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

    set 和 add添加是不一样的

    t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

t.add((1,2))
print(t) # {'Google', (1, 2), 'Taobao', 'Runoob'}

t.update((1,2)) # {1, 2, (1, 2), 'Taobao', 'Google', 'Runoob'}
print(t)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    set 删除 discard方法

    t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

# 这个删除方法 如果 元素 在set中 不存在会报错
t.remove('Google')
print(t) # {'Taobao', 'Runoob'}

# 这个方法 不会报错
t.discard(123) # {'Runoob', 'Taobao'}
print(t)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    随机删除

    t =  set(("Google", "Runoob", "Taobao"))
print(t) # {'Runoob', 'Taobao', 'Google'}

t.pop() # 随机删除 因为set中元素无序
print(t)

    • 1
    • 2
    • 3
    • 4
    • 5

    1、字典是一种映射类型，它的元素是键值对。
    2、字典的关键字必须为不可变类型，且不能重复。
    3、创建空字典使用 { }。

    数据类型转换

    int()

    
x = int(1)
x2 = int(2.2)
x3 = int("3")

print(x)
print(x2)
print(x3)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    float()

    x = float(1) # 1.0
x2 = float(2.8) # 2.8
x3 = float("3") # 3.0
x4 = float("4.2") # 4.2

print(x)
print(x2)
print(x3)
print(x4)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    str()

    
x = str("s1") # s1

x1 = str(2) # 2

x2 = str(3.0) # 3.0

print(x)
print(x1)
print(x2)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    推导式

    list推导式

    [表达式 for 变量 in 列表]

    [表达式 for 变量 in 列表 if 条件]

    names = ["alex", "stephow", "asd", "qwe","zzzzzz"]

names2 = [name.upper() for name in names ] 

print(names2) #['ALEX', 'STEPHOW', 'ASD', 'QWE', 'ZZZZZZ']



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    # 过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
names = ["alex", "stephow", "asd", "qwe","zzzzzz"]

print(names) # ['alex', 'stephow', 'asd', 'qwe', 'zzzzzz']

names2 = [name.upper() for name in names if len(name) > 3]

print(names2) # ['ALEX', 'STEPHOW', 'ZZZZZZ']



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    #计算 30及以内可以被 3 整除的整数
num = [i for i in range(31) if i % 3 == 0]
print(num) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

    • 1
    • 2
    • 3

    dict推导式

    { key_expr: value_expr for value in collection }

    { key_expr: value_expr for value in collection if condition }

    list = ['GAT', 'A', 'TQWEQWE']
dic = {key: len(key) for key in list} # {'GAT': 3, 'A': 1, 'TQWEQWE': 7}
print(dic) 

    • 1
    • 2
    • 3

    set 推导式

    { expression for item in Sequence }
    或
    { expression for item in Sequence if conditional }

    
s1 = {i ** 2 for i in range(3)} # {0, 1, 4}
print(s1)

s2 = {i ** 2 for i in {1, 2, 3}} # {1, 4, 9}
print(s2)

#判断不是 d c 的字母并输出
s3 = {x for x in 'asdasdasdaasdas' if x not in 'dc'} # {'s', 'a'}
print(s3)


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

    元组

    (expression for item in Sequence )
    或
    (expression for item in Sequence if conditional )

    a = (x for x in range(1, 10))
print(a) #  at 0x1084b5740>
print(tuple(a)) # (1, 2, 3, 4, 5, 6, 7, 8, 9)

b = (1,2)
print(b) # (1, 2)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    双重判断

    结果值1 if 判断条件 else 结果2 for 变量名 in 原列表

    
w = 'asd'
print(w.title()) # 首字符变大写 Asd
print(w.upper()) # 全部变大写 ASD

list1 = ['asdas', ' test1', 'test']

list2 = [w.title() if w.startswith('t') else w.upper() for w in list1] # ['ASDAS', ' TEST1', 'Test']

print(list2)




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

    输入

    input("请输入:")

    • 1

    打印 数

    a = input()

print(a)

    • 1
    • 2
    • 3

    for 循环

    sites = ["baidu", "google", "runoob"]
for s in sites:
    if s == "R":
        print(123213)

    elif s == "baidu":
        print("2")
    else:
        print("ok")
'''
2
ok
ok
'''

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

    for i in range(x) 循环

    # 0 - 4
for i in range(5):
    print(i)
# 1 - 4
for i in range(1, 5):
    print(i)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    步长

    # 0 - 4 只打印 步长为 2的数字
for i in range(0,5,2):
    print(i)
# 0 2 4

    • 1
    • 2
    • 3
    • 4
    # -1 到 -9
for i in range(-1, -10, - 1):
    print(i)

    • 1
    • 2
    • 3

    结合len的用法

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

for i in range(len(a)):
    print(a[i])

    • 1
    • 2
    • 3
    • 4

    range（x） 转化

    print(range(5)) # range(0, 5)
print(list(range(5))) # [0, 1, 2, 3, 4]
print(set(range(5))) # {0, 1, 2, 3, 4}
print({range(5)}) # {range(0, 5)}
print(tuple(range(5))) # (0, 1, 2, 3, 4)

    • 1
    • 2
    • 3
    • 4
    • 5

    Steak 栈

    定义

    栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。

    特点

    先进后出
    last-in first-out

    基本操作

    进栈 push
    出栈 pop
    取栈顶 gettop

    图

    在这里插入图片描述

    栈的实现

    li  = []
# 进栈 push
li.append(1)
# 出栈 pop
li.pop()
# 取栈顶 li[-1]
li[-1]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    class Stack:
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        return self.stack.pop()

    def get_top(self):

        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print(stack.pop())
print(stack.pop())
print(stack.pop())


    • 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 Stack:
    def __init__(self):
        self.stack = []

    def push(self, element):
        self.stack.append(element)

    def pop(self):
        return self.stack.pop()

    def get_top(self):

        if len(self.stack) > 0:
            return self.stack[-1]
        else:
            return None

    def is_empty(self):
        return len(self.stack) == 0

def brace_match(s):
    stack = Stack();

    math = {'}':'{',']':'[', ')':'('}

    for ch in s:
        if ch in {'(','{','['}:
            stack.push(ch)
        else:
            if stack.is_empty():
                return False
            elif stack.get_top() == math[ch]:
                stack.pop()
            else:
                return False

    return stack.is_empty()

print(brace_match('[][][][]()(){}{}'))


    • 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
    • 40

    Queue队列 使用总结

    定义

    队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。

    插入 rear 队尾
    删除 front 队首

    图

    先进先出
    First in First out
    在这里插入图片描述

    队列实现底层

    在这里插入图片描述
    当队尾指针front == Maxsize +1时，再前进一个位置就自动到O。

    队首指针前进1:front = (front + 1 % MaxSize
    队尾指针前进1: rear = (rear + 1 % MaxSize

    队空条件:rear == front
    队满条件:(rear + 1) % MaxSize 二二 front

    自己写一个队列

    class Queue:
    def __init__(self, size):
        self.queue = [0 for _ in range(size)]
        self.size = size
        self.rear = 0 #队尾 指针
        self.front = 0 # 队首 指针

    def push(self, element):

        if not self.is_filled():
            self.rear = (self.rear + 1) % self.size
            self.queue[self.rear] = element
        else:
            raise IndexError("Queue is filled!")

    def pop(self):

        if not self.is_empty():
            self.front = (self.front + 1) % self.size
            return self.queue[self.front]
        else:
            raise IndexError("Queue is empty!")

    def is_empty(self):
        return self.rear == self.front


    def is_filled(self):
        return (self.rear + 1) % self.size == self.front


q = Queue(6)
for i in range(5):
    q.push(i)

print(q.is_filled())
print(q.is_empty())
print(q.pop())
q.push(4)

    • 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

    常用方法

    创建Queue

    from collections import deque
q = deque() # 建空队列


q = deque([1,2,3]) # 建非空队列

q = deque([1,2,3], 5) # 第二参数设置queue的大小， 队伍满了之后，从前面开始出队

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    队尾添加元素

    q.append(1) # rear队尾进队

    • 1

    队首出元素

    q.popleft()

    • 1

    双向队列

    队尾添加
q.append(1)
队首添加
q.appendleft(1)
队首删除
q.popleft()
队尾删除
q.pop()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    队伍满了之后，从前面开始出队

    q = deque([1,2,3,4,5,6], 5) # 第二参数设置q的大小， 队伍满了之后，从前面开始出队
print(q.popleft()) # 2

    • 1
    • 2

    利用这个机制 可以实现 只读取 text文档的后5行

    # 双向队列
from collections import deque

def tail(n):
    with open('test.txt', 'r') as f:
        q = deque(f, n)
        return q


## 只读取text文档的5行
for line in tail(5):
    print(line, end = '')

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
  • 相关阅读:
    算法提升：图的Dijkstra(迪杰斯特拉)算法
    Lodash常用方法介绍
    取球游戏（C++）[堆]
    电脑换cpu要重装系统吗
    （三）Python Range循环
    最少刷题数
    MySQL 主从复制与读写分离
    笔记（四）传统图机器学习的特征工程-连接
    git的使用流程及git命令总结
    Tauri+Rust+Vue 跨平台桌面应用简明教程(1)环境创建+系统事件+自定义菜单
  • 原文地址：https://blog.csdn.net/weixin_46969441/article/details/127818677