python

发表于 更新于 分类于

类与对象

类主要定义对象的结构，类不但包含方法定义，而且还包含所有实例共享的数据。

对象是类的实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Exp: #类名大写
    #属性
    color = 'green'
    weight = 100
    legs = 4
    
    #方法
    def climb(self):
        print('爬行')
        
    def run(self):
        print("跑步")
        
e = Exp()
e.climb()
e.run()

多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Live:
    def run(self):
        raise AttributeRrror('子类必须实现这个方法')
        
class Pepole(Live):
    def run(self):
        print("人再走")
        
class Pig(LIve):
    def run(self):
        print('猪在跑')
        
def func(live):
    live.run()
    
func(Pig())

self

Python 的 self 相当于 C++ 的 this 指针。

类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称（对应于该实例，即该对象本身）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Ball:
    def setName(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,该死的，有人在踢我..." % self.name)


a = Ball()
a.setName("球A")
b = Ball()
b.setName("球B")

a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

__init__

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Ball:
    def __init__(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)


a = Ball("球A")
b = Ball("球B")
c = Ball("球C")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

公有和私有

1
在 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
27
28
29
30
31
32
33
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('小马的程序人生', 10, 60, 3)
s.speak()
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
41
42
43
44
45
46
47
import random

class Fish:
    def __init__(self):
        self.x = random.randint(0, 10)
        self.y = random.randint(0, 10)

    def move(self):
        self.x -= 1
        print("我的位置", self.x, self.y)


class GoldFish(Fish):  # 金鱼
    pass

class Shark(Fish):  # 鲨鱼
    def __init__(self):
        self.hungry = True

    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有得吃！")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")
            self.hungry = True

g = GoldFish()
g.move()  # 我的位置 9 4
s = Shark()
s.eat() # 吃货的梦想就是天天有得吃！
s.move()  
# AttributeError: 'Shark' object has no attribute 'x'

# 解决该问题可用以下两种方式：

# 一、调用未绑定的父类方法Fish.__init__(self)
class Shark(Fish):  # 鲨鱼
    def __init__(self):
        Fish.__init__(self)
        self.hungry = True            
            
# 二 使用super函数super().__init__()
class Shark(Fish):  # 鲨鱼
    def __init__(self):
        super().__init__()
        self.hungry = True

组合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Turtle:
    def __init__(self, x):
        self.num = x


class Fish:
    def __init__(self, x):
        self.num = x


class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)

    def print_num(self):
        print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))


p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只，小鱼3条

Taks6 函数与Lambda表达式

函数

1
2
def function(arg1,arg2=V,*args,**kw,*, nkw,):
​

arg1 - 位置参数 ，这些参数在调用函数 (call function) 时位置要固定。
arg2 = v - 默认参数 = 默认值,默认参数一定要放在位置参数 后面
args - 可变参数，可以是从零个到任意个，会存放所有未命名的变量参数。自动组装成元组(tuple)。
**kw - 关键字参数，可以是从零个到任意个，自动组装成字典。 (dict) , nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。

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

#### 闭包

如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。

```python
def funX(x):
    def funY(y):
        return x * y

    return funY


i = funX(8)
print(type(i))  # <class 'function'>
print(i(5))  # 40

递归

n! = 1 x 2 x 3 x ... x n

1
2
3
4
5
6
7
8
9
10
# 利用递归
def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

# 利用循环
n = 5
for k in range(1, 5):
    n = n * k

斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 利用递归
def recur_fibo(n):
    if n <= 1:
        return n
    return recur_fibo(n - 1) + recur_fibo(n - 2)


lst = list()
for k in range(11):
    lst.append(recur_fibo(k))
    
    
# 利用循环
i = 0
j = 1
lst = list([i, j])
for k in range(2, 11):
    k = i + j
    lst.append(k)
    i = j
    j = k
print(lst)

2. Lambda 表达式

1
lambda argument_list: expression

匿名函数 常常应用于函数式编程的高阶函数 (high-order function)中，主要有两种形式：

  • 参数是函数 (filter, map)
  • 返回值是函数 (closure)

filter(function, iterable) 过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

1
2
3
odd = lambda x: x % 2 == 1
templist = filter(odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist))  # [1, 3, 5, 7, 9]

map(function, *iterables) 根据提供的函数对指定序列做映射。

1
2
3
4
5
m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))

m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))

练习

  • 给函数参数和返回值注解？

    1
    def a(x: int, y: int) -> int:

  • 分别根据每一行的首元素和尾元素大小对二维列表 a = [[6, 5], [3, 7], [2, 8]] 排序。(利用lambda表达式)

    1
    2
    3
    a= [[6, 5], [3, 7], [2, 8]]
    b=sorted(a,key=(lambda x:x[0]))
    c=sorted(a,key=(lambda x:x[1]))

  • 利用python解决汉诺塔

    image-20200803083445044

    规律：

    每次都是以 a 或 b 中一根柱子为缓冲

    先将除了最下面的圆盘之外的其它圆盘移动到辅助柱子上

    再将最底下的圆盘移到 目标柱子上

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    def hanoi(n, a, b, c):
        # a 上只有一个盘子（肯定是最大的），直接搬到 c
        if n == 1:
            i += 1
            print('移动第 {0} 次 {1} --> {2}'.format(i, a, c))
            return
        else:
            # 
            hanoi(n - 1, a, c, b)
    		hanoi（1，a, b, c）
            hanoi(n - 1, b, a, c)

    hanoi(64, 'A', 'B', 'C')

Task5 字典 集合 序列

字典

{（key:value）（key:value）（key:value）}

字典以”关键字”为索引，关键字可以是任意不可变类型，通常用字符串或数值。

快速判断数据类型 X 是不是可变类型：

用 hash(X)，只要不报错，证明 X 可被哈希，即不可变。

方法

  • dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
  • dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。
  • dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
  • dict.items()以列表返回可遍历的 (键, 值) 元组数组。
  • dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。
  • dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
  • key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回true，否则返回false。而not in操作符刚好相反，如果键在字典 dict 里返回false，否则返回true。
  • dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。
  • del dict[key] 删除字典给定键 key 所对应的值
  • dict.popitem()随机返回并删除字典中的一对键和值
  • dict.clear()用于删除字典内所有元素。
  • dict.update(dict2)把字典参数 dict2 的 key:value对 更新到字典 dict 里。

练习一：

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
dic = {
    'python': 95,
    'java': 99,
    'c': 100
    }
print('字典长度为：',len(dic))
# 字典长度为： 3
dic['java'] = 98
print(dic)
# {'python': 95, 'java': 98, 'c': 100}
del dic['c']
print(dic)
# {'python': 95, 'java': 98}
dic['php'] = 90
print(dic)
# {'python': 95, 'java': 99, 'c': 100, 'php': 90}
key_list = list(dic.keys())
print(key_list)
# ['python', 'java', 'c', 'php']
value_list = list(dic.values())
print(value_list)
# [95, 99, 100, 90]
print('javascript' in dic)
# False
value_list = list(dic.values())
print(sum(value_list))

for key,value in dic.items():
    if(value == max(dic.values())):
        print(key,value)
        
for key,value in dic.items():
    if(value == min(dic.values())):
        print(key,value)
dic1 = {'php': 97}
dic.update(dic1)
print(dic)

2、字典中的value

有一个字典，保存的是学生各个编程语言的成绩，内容如下

1
2
3
4
5
data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }

请实现函数transfer_score(score_dict)，将分数修改成int类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def transfer_score(data):
    # your code here
    for value in data.values():
    if isinstance(value,dict):
        for k,v in value.items():
            value[k] = int(v)
            
    if isinstance(value,list):
        for l in value:
            if isinstance(l,str):
                value[value.index(l)] = int(l)
                
            if isinstance(l,dict):
                for k,v in l.items():
                    l[k] = int(v)
                
print(data)

集合 set

使用s = set()创建集合，s = {}创建空字典。

  • 重复元素在set中会被自动被过滤。

  • set(value)列表或元组转换成集合

  • 集合的两个特点：无序 (unordered) 和唯一 (unique)。

  • set.add(elmnt)：添加元素

  • `set.update(set)：添加新的元素或集合

  • set.remove(item) ：移除存在的元素

  • set.discard(value) 移除元素，不存在也可以

  • set.pop() 用于随机移除一个元素。

  • 交集

    1
    2
    3
    set.intersection(set1, set2) 
    set1 & set2 
    set.intersection_update(set1, set2)  #在原始的集合上移除不重叠的元素

  • 并集

    1
    2
    set.union(set1, set2)
    set1 | set2

  • 差集

    1
    2
    3
    set.difference(set) 
    set1 - set2 
    set.difference_update(set) # 直接在原来的集合中移除元素，没有返回值

  • 异或

    1
    2
    3
    set.symmetric_difference(set)
    set1 ^ set2
    set.symmetric_difference_update(set) # 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中

  • 包含、被包含 

    1
    2
    3
    set1 <= set2   /  set.issubset(set)

    set1 >= set2   / set.issuperset(set)

  • set.isdisjoint(set) 用于判断两个集合是否 不相交

练习二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
set={1}
print(set,type(set))
# {1} <class 'set'>

new_set = set()
for i in {'x','y','z'}:
    new_set.add(i)
print(new_set)

set(['A', 'B', 'A', 'B'])

set1 = {6, 7, 8}
set2 = {7, 8, 9}
set1.difference(set2) | set2.difference(set1)

for i in {'A', 'B', 'C'}:
    print(i,'出现次数：',int(i in {'B', 'C', 'D'}))
# A 出现次数： 0
# C 出现次数： 1
# B 出现次数： 1

序列（sub）

  • list(sub) 、tuple(sub) 、str(obj) 、len(s) 、max(sub)、min(sub)、sum(iterable[, start=0]) 、sorted(iterable, key=None, reverse=False) 、reversed(seq)

  • enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    a = list(enumerate(seasons))
    print(a)  
    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

    for i, element in a:
        print('{0},{1}'.format(i, element))
    # 0,Spring
    # 1,Summer
    # 2,Fall
    # 3,Winter

  • zip(iter1 [,iter2 [...]])

    • 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象

    • 利用 * 号操作符，可以将元组解压为列表。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      a = [1, 2, 3]
      b = [4, 5, 6]
      c = [4, 5, 6, 7, 8]

      zipped = zip(a, b)
      print(zipped)  # <zip object at 0x000000C5D89EDD88>
      print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
      zipped = zip(a, c)
      print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]

      a1, a2 = zip(*zip(a, b))
      print(list(a1))  # [1, 2, 3]
      print(list(a2))  # [4, 5, 6]

练习三

  1. sort() 和 sorted() 区别

    （1）sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。

    iterable – 可迭代对象。

    key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

    reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    返回重新排序的列表

    （2）sort()是列表类型的方法，只适用于列表；

    （3）sorted()是内置函数，支持各种容器类型。它们都可以排序，且用法类似，但sort()是在原地排序的，不会返回排序后的列表，而sorted()是返回新的排序列表

1
2
3
4
5
6
7
8
9
# 1 到 100 所有整数相加
sum(range(1,101))
#  [2,3,4,5] 中每个元素的立方根
for i in [2,3,4,5]:
    print(i,'的立方根是：',i**3)
# 将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式
list1 = ['x','y','z'] 
list2 = [1,2,3]
print([*zip(list1,list2)])

Task4 List Tuple String

List

定义

1
2
3
list = [ , , ]
' ' 中可以是任意类型的 Python 对象
列表内容可更改 (mutable)、附加 (append, extend)、插入 (insert)、删除 (remove, pop)

创建

  • 直接创建：list = [‘x’,’y’,’z’]；list = [[1,2],[3,4]]

  • range()创建列表：x = list(range(10))；x = [[0] * 3 for row in range(4)]

  • 推导式创建列表：

    1
    2
    3
    4
    5
    x = [0] * 5   # [0, 0, 0, 0, 0] 

    x = [i for i in range(5)]  # [0, 1, 2, 3, 4]

    x = [[0 for col in range(3)] for row in range(4)] # 4×3的二维数组

添加

  • list.append(obj)：把一个东西整体添加在列表后
  • list.extend(obj)：把一个东西里的所有元素添加在列表后
  • list.insert(index,obj)：在编号 index 位置插入 obj

删除

  • lsit.remove(obj)：移除列表中的第一个匹配项
  • list.pop([index=-1]) ：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
  • del var1[, var2 ……] ：删除单个或多个对象

获取

  • 列表索引值是从0开始，索引-1返回最后一个列表元素，索引 -2 返回倒数第二个列表元素
切片写法是 start : stop : step

  • start

    1
    2
    3
    x = ['0, '1', '2', '3', '4']
    print(x[3:])  # ['3', '4']
    print(x[-3:])  # ['2', '3', '4']

  • stop

    1
    2
    3
    week = ['0', '1', '2', '3', '4']
    print(week[:3])  # ['0', '1', '2']
    print(week[:-3])  # ['0', '1']

  • start : stop

    1
    2
    3
    x = ['0, '1', '2', '3', '4']
    print(x[1:3])  # ['1', '2']
    print(x[-3:-1])  # ['2', '3']

  • start : stop : step

    1
    2
    3
    4
    5
    x = ['0, '1', '2', '3', '4']
    print(x[1:4:2]) # ['1', '3']
    print(x[:4:2])  # ['0', '2']
    print(x[1::2])  # ['1', '3']
    print(x[::-1])  #['4', '3', '2', '1', '0']

其它方法

  • list.count(obj) 统计某个元素在列表中出现的次数

  • list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置

  • list.reverse() 反向列表中元素

  • list.sort(key=None, reverse=False) 对原列表进行排序。

    1
    2
    3
    4
    5
    6
    7
    8
    x = [(2, 2), (3, 4), (4, 1), (1, 3)]
    x.sort(key=takeSecond)
    print(x)
    # [(4, 1), (2, 2), (1, 3), (3, 4)]

    x.sort(key=lambda a: a[0])
    print(x)
    # [(1, 3), (2, 2), (3, 4), (4, 1)]

作业

  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    l = [2, 5, 6, 7, 8, 9, 2, 9, 9]

    l.append(15)               #在列表的末尾增加元素15
    l.insert(len(l)//2,20)     #在列表的中间位置插入元素20
    l = l + [2,5,6]            #将列表[2, 5, 6]合并到lst中
    l.pop(3)                   #移除列表中索引为3的元素
    l.reverse()                #翻转列表里的所有元素
    l.sort()                   #排序，从小到大一次，从大到小一次
    l.sort(reverse = True)
  2. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    lst = [1, [4, 6], True]
    #将列表里所有数字修改成原来的两倍
    def double_list (l):
        for i in range(len(l)):
            if type(l[i]) is int:
                l[i]=2*l[i]
            elif type(l[i]) is list:
                l[i]=double_list(l[i])
        return l
    a=double_list(lst)
    print(a)

  3. leetcode 852题 山脉数组的峰顶索引

    • 数组的长度大于等于3
    • $\mathrm{k}[0]<\mathrm{k}[1]<\ldots<\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1] \ldots>\mathrm{k}[\operatorname{len}(\mathrm{k})-1]$
    1
    2
    3
    4
    5
    class Solution:
        def peakIndexInMountainArray(self, A: List[int]) -> int:
          for i in range(1,len(A)):
            if  A[i-1]<A[i]>A[i+1]:
              return i

Tuple

定义：(元素1, 元素2, ..., 元素n)，被创建后就不能对其进行修改

更新和删除一个元组

1
2
3
4
5
6
7
8
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)  # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

# 无法通过赋值语句更改元组内的元素。但倘若元组内的元素是可更改的（如列表），那就可以更改元组中的元素。
t1 = (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

内置方法

只有 count 和 index 两种方法。

count记录在元组 t 中该元素出现几次，index 找到在元组 t 的索引

解压元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
t = (1, 10.31, 'python')
(a, b, c) = t

t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c)  # 1 2 5
print(rest)  # [3, 4]

t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b)  # 1 2

==String==

常用内置方法

  • capitalize() 将字符串的第一个字符转换为大写。

  • lower() 转换字符串中所有大写字符为小写。

  • upper() 转换字符串中的小写字母为大写。

  • swapcase() 将字符串中大写转换为小写，小写转换为大写。

  • count(str, beg= 0,end=len(string))

  • endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串结束，True、FALSE

  • startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串开始，True、FALSE

  • find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，包含，返回开始的索引值，否则返回 -1。

  • isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False。

  • ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

  • rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。

    1
    2
    3
    str4 = '1101'
    print(str4.ljust(8, '0'))  # 11010000
    print(str4.rjust(8, '0'))  # 00001101

  • lstrip([chars]) 截掉字符串左边的空格或指定字符。

  • rstrip([chars]) 删除字符串末尾的空格或指定字符。

  • ==strip([chars]) 在字符串上执行lstrip()和rstrip()。==

  • partition(sub) 找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。

    1
    2
    3
    4
    str5 = ' I Love LsgoGroup '
    print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')
    print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')
    print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')

  • ==replace(old, new [, max]) 把 将字符串中的old替换成new，如果max指定，则替换不超过max次。==

  • ==split(str="", num) 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。==

    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
    41
    42
    43
    44
    str5 = ' I Love LsgoGroup '
    print(str5.strip().split())  # ['I', 'Love', 'LsgoGroup']
    print(str5.strip().split('o'))  # ['I L', 've Lsg', 'Gr', 'up']

    u = "www.baidu.com.cn"
    # 使用默认分隔符
    print(u.split())  # ['www.baidu.com.cn']

    # 以"."为分隔符
    print((u.split('.')))  # ['www', 'baidu', 'com', 'cn']

    # 分割0次
    print((u.split(".", 0)))  # ['www.baidu.com.cn']

    # 分割一次
    print((u.split(".", 1)))  # ['www', 'baidu.com.cn']

    # 分割两次
    print(u.split(".", 2))  # ['www', 'baidu', 'com.cn']

    # 分割两次，并取序列为1的项
    print((u.split(".", 2)[1]))  # baidu

    # 分割两次，并把分割后的三个部分保存到三个变量
    u1, u2, u3 = u.split(".", 2)
    print(u1)  # www
    print(u2)  # baidu
    print(u3)  # com.cn


    c = '''say
    hello
    baby'''

    print(c)
    # say
    # hello
    # baby

    print(c.split('\n'))  # ['say', 'hello', 'baby']

    string = "hello boy<[www.baidu.com]>byebye"
    print(string.split('[')[1].split(']')[0])  # www.baidu.com
    print(string.split('[')[1].split(']')[0].split('.'))  # ['www', 'baidu', 'com']

  • splitlines([keepends]) 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。

    1
    2
    3
    str6 = 'I \n Love \n LsgoGroup'
    print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
    print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

  • maketrans(intab, outtab) 创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

  • translate(table, deletechars="") 根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

    1
    2
    3
    4
    5
    6
    str7 = 'this is string example....wow!!!'
    intab = 'aeiou'
    outtab = '12345'
    trantab = str7.maketrans(intab, outtab)
    print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
    print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

字符串格式化

1
2
3
4
5
6
7
8
9
10
11
str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置参数
print(str8)  # I Love Lsgogroup

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 关键字参数
print(str8)  # I Love Lsgogroup

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置参数要在关键字参数之前
print(str8)  # I Love Lsgogroup

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB
符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串，用str()方法处理对象
%r 格式化字符串，用rper()方法处理对象
%d 格式化整数
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g 根据值的大小决定使用%f或%e
%G 作用同%g，根据值的大小决定使用%f或%E 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'
符号 功能
m.n m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
- 用作左对齐
+ 在正数前面显示加号( + )
# 在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0 显示的数字前面填充’0’而不是默认的空格

作业

  1. 字符串函数回顾

  2. 实现isdigit函数：字符串里是否只包含数字0~9

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    def isdigit(string):
        """
        判断字符串只包含数字
        :param string:
        :return:
        """
        # your code here
        flag = True if string.isnumeric() else False
        return flag
    a = input("请输入：")
    flag = isdigit(a)
    print(flag)

  3. leetcode 5题 最长回文子串

    给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

    “回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。

    示例:
    输入: “babad”
    输出: “bab”
    输入: “cbbd”
    输出: “bb”

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class Solution:
        def longestPalindrome(self, s: str) -> str:
          l = len(s)
          maxlen = 0
          maxstr = ''
           for i in range(l):
               for j in range(i+1,l+1):
                   temp =s[i:j] 
                   if temp == temp[::-1] and j-i > maxlength:
                       maxstr = s[i:j]
                       maxlength = j-i
           return maxstr

Task3_作业

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

num = random.randint(0,100)
i = 0
while 1:
    i+=1
    print('第%s次猜，请输入0到100的整数'%i)
    n = input("输入一个0到100的整数：")
    try:
        n=int(n)
    except:
        print('输入无效')
    else:
        if n<num:
            print('小了')
        elif n > num:
            print("大了")
        elif n == num:
            print("恭喜你猜对了答案是%s"%num)
            break

image-20200725185322609

Python标准警告总结

  • Warning：警告的基类
  • DeprecationWarning：关于被弃用的特征的警告
  • FutureWarning：关于构造将来语义会有改变的警告
  • UserWarning：用户代码生成的警告
  • PendingDeprecationWarning：关于特性将会被废弃的警告
  • RuntimeWarning：可疑的运行时行为(runtime behavior)的警告
  • SyntaxWarning：可疑语法的警告
  • ImportWarning：用于在导入模块过程中触发的警告
  • UnicodeWarning：与Unicode相关的警告
  • BytesWarning：与字节或字节码相关的警告
  • ResourceWarning：与资源使用相关的警告

random

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
#!/usr/bin/python
# -*- coding: UTF-8 -*-

import random
import string

# 随机整数：
print random.randint(1,50)

# 随机选取0到100间的偶数：
print random.randrange(0, 101, 2)

# 随机浮点数：
print random.random()
print random.uniform(1, 10)

# 随机字符：
print random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()')

# 多个字符中生成指定数量的随机字符：
print random.sample('zyxwvutsrqponmlkjihgfedcba',5)

# 从a-zA-Z0-9生成指定数量的随机字符：
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
print ran_str

# 多个字符中选取指定数量的字符组成新字符串：
print ''.join(random.sample(['z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'], 5))

# 随机选取字符串：
print random.choice(['剪刀', '石头', '布'])

# 打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print random.shuffle(items)

Task2_作业

  1. 编写一个Python程序来查找那些既可以被7整除又可以被5整除的数字，介于1500和2700之间。
1
2
3
x = [i for i in range(1500,2700) if (i%5) == 0 and (i%7) == 0]

==>[1505, 1540, 1575, 1610, 1645, 1680, 1715, 1750, 1785, 1820, 1855, 1890, 1925, 1960, 1995, 2030, 2065, 2100, 2135, 2170, 2205, 2240, 2275, 2310, 2345, 2380, 2415, 2450, 2485, 2520, 2555, 2590, 2625, 2660, 2695]
  1. 龟兔赛跑游戏

题目描述：任一秒结束后兔子发现自己领先**x米或以上，会停下s秒**。对于不同的兔子，x，s的数值是不同的，但是所有的乌龟却是一致——它们不到终点决不停止。

兔子的速度v1（表示每秒兔子能跑v1 米），乌龟的速度v2，以及兔子对应的x，s值，以及赛道的长度l——就能预测出比赛的结果。写一个程序，对于输入的一场比赛的数据v1，v2，x，s，l，预测该场比赛的结果。

输入: 输入只有一行，包含用空格隔开的五个正整数v1，v2，x，s，l，其中(v1,v2< =100;x< =300;s< =10;l< =10000且为v1,v2的公倍数)

输出: 输出包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点。

第二行输出一个正整数，表示获胜者（或者双方同时）到达终点所耗费的时间（秒数）。

样例输入：

10 5 5 2 20

样例输出

D
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
def end(l_1,l_2,l):
    if l_1 >= l or l_2 >= l: #有一方到达终点
        if l_1 == l_2 == l:
            return ("D") #同时
        elif l_1 > l_2: 
            return ("R") #兔子赢
        elif l_1 < l_2 : 
            return "T" #乌龟赢
    pass

def competition(v1:int,v2:int,x:int,s:int,l:int):
    l_1,l_2,t = 0,0,0
    #l_1 = v1*t
    #l_2 = v2*t
    
    while 1 :
        back = end(l_1,l_2,l)
        if back:
            break
        
        if l_1-l_2 < x : #兔子不领先
            t+=1
            l_1 += v1
            l_2 += v2
        else:
            while s>0:
                t+=1
                l_2 += v2
                s-=1

    print(back,'\n',t)
    
    
    
if __name__ == "__main__":
    competition(10,5,5,2,20)

Task1_作业

  1. 怎样对python中的代码进行注释？

  • #注释单行

  • ''' ''' 或者 """ """ 表示区间注释，中间内容被注释

  • 快捷键cmd+?，可以通过#快速注释多行
  1. python有哪些运算符，这些运算符的优先级是怎样的？

  • 算术运算符：+、-、*、/、%、**、//

  • 比较运算符：==、!=、>、<、>=、<=

  • 赋值运算符：=、 +=、 -=、 =、 /=、 %=、 *=、 //=、 ==:=（海象运算符，3.8新增）==

  • 位运算符：&、 | 、^ 、~

  • 逻辑运算符：and 、or、not

  • 成员运算符：in、not in

  • 身份运算符：is 、not is

    优先级：

    | 运算符 | 描述 |
    | ———————————— | ——————————————————————————— |
    | | 指数 (最高优先级) |
    | ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
    | / % // | 乘，除，求余数和取整除 |
    | + - | 加法减法 |
    | >> << | 右移，左移运算符 |
    | & | 位 ‘AND’ |
    | ^ | | 位运算符 |
    | <= < > >= | 比较运算符 |
    | == != | 等于运算符 |
    | = %= /= //= -= +=     =     = | 赋值运算符 |
    | is is not | 身份运算符 |
    | in not in | 成员运算符 |
    | not and or | 逻辑运算符 |

  1. python 中 is, is not 与 ==, != 的区别是什么？
1
2
身份运算符用于比较两个对象的存储单元，
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
  1. python 中包含哪些数据类型？这些数据类型之间如何转换？

  • Number（数字）——不可变数据

  • String（字符串）——不可变数据

  • Tuple（元组）——不可变数据

  • List（列表）——可变数据

  • Set（集合）——可变数据

  • Dictionary（字典）——可变数据

函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

本文标题:python

文章作者:ZQ Liu

发布时间:2020年07月22日 - 16:38:08

最后更新:2020年08月18日 - 16:31:29

原始链接:http://yoursite.com/2020/07/22/python/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

-------------本文结束感谢您的阅读-------------

欢迎关注我的其它发布渠道