Python学习笔记（Day1-Day5）

前言

本蒻苟已粗略学习过c++基础，略去大部分相似且熟悉部分。
主要参考1
主要参考2

关于Python

Python由荷兰数学和计算机科学研究学会的Guido van Rossum 于1990 年代初，出于打发时间的目的设计（这就是dalao吧），就连Python的名字也是源于当时他正在看的电视剧“Monty Python’s Flying Circus”。

（就是这位帅哥）

Python之禅
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!
（翻译自行百度）

Python2.x 与 3​​.x 版本区别

• 参考

Python与c++区别

Python是一种脚本语言，是解释执行的，不需要经过编译，所以很方便快捷，且能够很好地跨平台，写一些小工具小程序特别合适。

而C++则是一种需要编译后运行语言，在特定的机器上编译后在特定的机上运行，运行效率高，安全稳定。但编译后的程序一般是不跨平台的。

小方面：

1. 在Python中没有switch语句。你可以使用if…elif…else语句来完成同样的工作（在某些场合，使用字典会更加快捷。）
2. 在Python中没有专门的char数据类型。
3. 单引号和双引号字符串是完全相同的——它们没有在任何方面有不同
4. 在C/C++中，如果你想要写for (int i = 0; i < 5; i++)，那么用Python，你写 成for i in range(0,5)。Python的for循环更加简单、明白、不易出错。
5. Python中是没有&&及||这两个运算符的，取而代之的是英文and和or。
6. Python中单独使用!无特殊含义，非为not，但是有!=运算符
7. Python 里面万物皆对象（object），整型也不例外，只要是对象，就有相应的属性 （attributes） 和方法（methods）。
8. Python中没有连加、连减操作符

小操作

• 注释:
  在 Python 中，# 表示注释，作用于整行。或者一对三个单引号/三个双引号表示区间注释，在三引号之间的所有内容被注释。
• 单双引号：
  单引号跟双引号的普通用法相同, 与C++中用双引号表示字符串的用法一样，区别主要体现在当用单引号包起来的字符串里包含"的时候, 不需要使用转义符(), 反过来也是一样,如：

print( "let's go" )
print( 'lalala"lalala"lala' ) #没想到例子瞎写一个吧

• 三引号:
  一对连续的单引号或者双引号,允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

 print('''abc
 xyz
 ghi''')
#输出结果：
abc
xyz
ghi

 person = """name  # 姓名
 age   # 年龄
 sex   # 性别
 """
 print（person）
#输出结果
name  # 姓名
age   # 年龄
sex   # 性别
'''
多行注释
可用三引号
'''

Day1：变量、运算符、数据类型及位运算

运算符

-运算符优先级和结合性

算术运算符

操作符	名称
//	整除（地板除，向下取整）
**	乘方

例：

print(3 // 4)  # 0
print(2 ** 3)  # 8
print(3**2**3) # 6561

逻辑运算符

操作符	名称
and	与
or	或
not	非

例：

print((3 > 2) and (3 < 5))  # True
print((1 > 3) or (9 < 2))   # False
print(not (2 > 1))          # False

位运算符

操作符	名称
~	按位取反
&	按位与 4 & 5
|	按位或
^	按位异或 4 ^ 5
<<	左移 4 << 2
>>	右移

例：

print(bin(4))  # 0b100
print(bin(5))  # 0b101
print(bin(~4), ~4)  # -0b101 -5
print(bin(4 & 5), 4 & 5)  # 0b100 4
print(bin(4 | 5), 4 | 5)  # 0b101 5
print(bin(4 ^ 5), 4 ^ 5)  # 0b1 1
print(bin(4 << 2), 4 << 2)  # 0b10000 16
print(bin(4 >> 2), 4 >> 2)  # 0b1 1

三元运算符

例：

x, y = 4, 5
small = x if x < y else y
print(small)  # 4

其他

操作符	名称
in	存在
not in	不存在
is	是
is not	不是

例：

letters = ['A', 'B', 'C']
if 'A' in letters:
    print('A' + ' exists')
if 'h' not in letters:
    print('h' + ' not exists')

# A exists
# h not exists

注：

• is, is not 对比的是两个变量的地址，而 ==，!= 比较的是两个变量的值
  具体参考Python中is和==的区别

数据类型

获取数据类型

• type(object) 获取类型信息
• 不会认为子类是一种父类类型，不考虑继承关系。
  例：

print(type(1))       # <class 'int'>
print(type(5.2))     # <class 'float'>
print(type(True))    # <class 'bool'>
print(type('5.2'))   # <class 'str'>

• isinstance(object, classinfo) 判断一个对象是否是一个已知的类型。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。
  例：

print(isinstance(1, int))      # True
print(isinstance(5.2, float))  # True
print(isinstance(True, bool))  # True
print(isinstance('5.2', str))  # True

类型转换

• 转换为整型 int(x, base=10)
• 转换为字符串 str(object=’’)
• 转换为浮点型 float(x)

print()函数

位运算

原码、反码、补码

• 原码：数字绝对值的二进制，最高位为符号位（0表示正，1表示负）
• 反码：正数的反码与其原码相同；负数的反码是对正数逐位取反，符号位保持为1。
• 补码：正数的补码与其原码相同；负数的补码是在其反码的末位加1。

运算符对应操作

参考

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

例：

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0

c = a & b;        # 12 = 0000 1100
print "1 - c 的值为：", c
 
c = a | b;        # 61 = 0011 1101 
print "2 - c 的值为：", c
 
c = a ^ b;        # 49 = 0011 0001
print "3 - c 的值为：", c
 
c = ~a;           # -61 = 1100 0011
print "4 - c 的值为：", c
 
c = a << 2;       # 240 = 1111 0000
print "5 - c 的值为：", c
 
c = a >> 2;       # 15 = 0000 1111
print "6 - c 的值为：", c

练习题：

leetcode 习题 136. 只出现一次的数字

• 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。尝试使用位运算解决此题。
• 注意到：一个数如果连续异或了两个相同的数，他将保持不变。（开整！）
  例：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        i = 0
        for num in nums:
            i ^= num
        return i

Day2:条件、循环结构

条件结构

if - elif - else 语句

• 相当于 else if

assert 关键词

• assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常,程序自动崩溃并抛出AssertionError的异常。
• assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。

循环结构

• Python 提供了 for 循环和 while 循环（在 Python 中没有 do…while 循环）。

while - else 循环

• 当while循环正常执行完的情况下，执行else输出，，如果while循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容。

for 循环

• for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如str、list、tuple等，也可以遍历任何可迭代对象，如dict(字典)。
• 每次循环，迭代变量被设置为可迭代对象的当前元素，提供给代码块使用。
  例：

'''
for 迭代变量 in 可迭代对象:
    代码块
'''
for i in 'ILoveRM':
    print(i, end=' ')  # 不换行输出
#输出结果
# I L o v e R M


dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for key, value in dic.items():
    print(key, value, sep=':', end=' ')
#输出结果    
# a:1 b:2 c:3 d:4

for - else 循环

• 当for循环正常执行完的情况下，执行else输出，，如果for循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容，与while - else语句一样。

range() 函数

• 这个BIF（Built-in functions）有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。
• step 步长，默认为1。
• range 这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列，该序列包含start的值但不包含stop的值。
  例：

range([start,] stop[, step=1])


for i in range(1, 10, 2):
    print(i)
#输出结果
# 1
# 3
# 5
# 7
# 9

enumerate()函数

• sequence – 一个序列、迭代器或其他支持迭代对象。
• start – 下标起始位置。
• 返回 enumerate(枚举) 对象
• 用 enumerate(A) 不仅返回了 A 中的元素，还顺便给该元素一个索引值 (默认从 0 开始)。此外，用 enumerate(A, j) 还可以确定索引起始值为 j。

enumerate(sequence, [start=0])


seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]


#与for结合
seq = ['one', 'two', 'three']
for i, element in enumerate(seq, start = 1):  #下标从 1 开始
     print i, element
 
#1 one
#2 two
#3 three

循环控制语句

循环控制语句可以更改语句执行的顺序。
Python支持以下循环控制语句：

控制语句	描述
break 语句	在语句块执行过程中终止循环，并且跳出整个循环
continue 语句	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句	pass是空语句，是为了保持程序结构的完整性。

推导式

• 列表推导式

[ expr for value in collection [if condition] ]


a = [i for i in range(50) if not(i%2) and i%3] #注意列表是中括号 三项内容 变量 循环体 判断条件
print(a) #输出为符合判断条件的结果 50以内能被2整除且不能被3整除的数字

#[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46]

• 元组推导式
  注意到使用元组推导式生成的结果并不是一个元组，而是一个生成器对象，此时解决方法 参考

( expr for value in collection [if condition] )


a = (x for x in range(10))
print(a)

# <generator object <genexpr> at 0x0000025BE511CC48>

print(tuple(a))

# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

• 字典推导式

{ key_expr: value_expr for value in collection [if condition] }


b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0} #注意 冒号 ':' 三项内容 变量 条件 循环体
print(b) #输出结果和列表推导式不同，如果判断条件成立 输出就是True 否则输出False
# {0: True, 3: False, 6: True, 9: False}

• 集合推导式

{ expr for value in collection [if condition] }


c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}#注意 两项内容 变量 循环体
print(c)#输出内容 为本例中的列表的非重复输出
# {1, 2, 3, 4, 5, 6}

• 其他

d = 'i for i in "I Love Lsgogroup"' #想弄字符串推导式但显然不行
print(d)
# i for i in "I Love Lsgogroup"

e = (i for i in range(10))  
print(e)
# <generator object <genexpr> at 0x0000007A0B8D01B0> #整了个迭代器？？？

print(next(e))  # 0
print(next(e))  # 1

for each in e:
    print(each, end=' ')

# 2 3 4 5 6 7 8 9

s = sum([i for i in range(101)])
print(s)  # 5050
s = sum((i for i in range(101))) #生成器推导式 此处中间层小括号可省略
print(s)  # 5050

• 综合例子

#三次机会判断输入数字是否在列表
passwdList = ['123', '345', '890'] 
valid = False
count = 3
while count > 0:
    password = input('enter password:')
    for item in passwdList:
        if password == item:
            valid = True
            break
            
    if not valid:
        print('invalid input')
        count -= 1
        continue
    else:
        break

练习题

• 编写一个Python程序来查找那些既可以被7整除又可以被5整除的数字，介于1500和2700之间

for i in range(1500, 2700):
    if i % 35 == 0:
        print(i)

• 龟兔赛跑游戏 题干链接

v1,v2,t,s,l = (input('请输入五个正整数v1（兔速），v2(龟速)，t(领先距离),s(休息时间)，l(赛道长)').split())

v1 = int(v1)
v2 = int(v2)
t = int(t)
s = int(s)
l = int(l)

distance_r = distance_t = 0 #兔子和乌龟跑过的距离
time_r = time_t = 0         #兔子和乌龟跑过的时间

while distance_t<l and distance_r<l:
    if distance_r - distance_t >= t :
        time_t += s
        distance_r = v1 * time_r
        distance_t = v2 * time_t
    else :
        time_r += 1
        time_t += 1
        distance_r = v1 * time_r
        distance_t = v2 * time_t
        
if distance_r == distance_t :
    print('D',time_t,sep = '\n')
elif distance_r > distance_t :
    print('R',time_t,sep = '\n')
else :
    print('T',int(l/v2),sep = '\n')

Day3:异常处理

计算机语言针对可能出现的错误定义了异常类型，某种错误引发对应的异常时，异常处理程序将被启动，从而恢复程序的正常运行。

什么是异常？

• 异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

• 一般情况下，在Python无法正常处理程序时就会发生一个异常。

• 异常是Python对象，表示一个错误。

• 当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

Python标准异常

异常名称	描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError Python	语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

try - except 语句

• 首先，执行try子句（在关键字try和关键字except之间的语句）
• 如果没有异常发生，忽略except子句，try子句执行后结束。
• 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和except之后的名称相符，那么对应的except子句将被执行。最后执行try语句之后的代码。

try:
    检测范围
except Exception[as reason]:
    出现异常后的处理代码


try:
    a = b
    print(a)
except:
    print("Error")  
print("lalala")
#运行结果
#Error
#lalala

• 一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。

try:
    s = 1 + '1'
    int("abc")
    f = open('test.txt')
    print(f.read())
    f.close()
except (OSError, TypeError, ValueError) as error:
    print('出错了！\n原因是：' + str(error))
#输出结果
# 出错了！
# 原因是：unsupported operand type(s) for +: 'int' and 'str'

• 一个try语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
• 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

try:
    a = b
    print(a)
except SyntaxError:
    print("SyntaxError")
except NameError:
    print("NameError")
#运行结果
#NameError

try - except - else 语句

• 有异常时，else block不执行，无异常则执行

try:
    正常的操作
except(Exception1[, Exception2[,...ExceptionN]]]):
   发生以上多个异常中的一个，执行这块代码
else:
    如果没有异常执行这块代码

try - except - finally 语句

• 不管try子句里面有没有发生异常，finally子句都会执行。

• 如果一个异常在try子句里被抛出，而又没有任何的except把它截住，那么这个异常会在finally子句执行后被抛出。

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

raise语句

• 用于抛出一个指定的异常
• 参考

练习题

• 猜数字游戏

• 电脑产生一个零到100之间的随机数字，然后让用户来猜，如果用户猜的数字比这个数字大，提示太大，否则提示太小，当用户正好猜中电脑会提示，“恭喜你猜到了这个数是…”。在用户每次猜测之前程序会输出用户是第几次猜测，如果用户输入的根本不是一个数字，程序会告诉用户"输入无效"。

• (尝试使用try catch异常处理结构对输入情况进行处理)

• 获取随机数采用random模块。

import random

num = random.randint(1, 10)
guess = 233
time = 1

while guess != num:
    print("第%d次输入" %time)

    try:
        guess = int(input("请输入一个1至10之间的数字:" ))
        print(guess)
        
    except:
        print("输入无效")
        time += 1
    else:
        if guess == num:
            print("恭喜你猜到了这个数是%d" %num)
            break
        elif guess > num:
            print("大了")
            continue
        else:
            print("小了")
            continue
        time += 1

Day4：列表、元组和字符串

列表（list）

• 定义：列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, …, 元素n] 。
• 于list的元素可以是任何对象（这意味着列表内的对象可以是不同类型），因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。
• 列表索引从 0 开始，第二个索引是 1，依此类推。(同c++数组类似），但同时索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
• 可以创建空列 ( [] 内无内容）
• 可用 [] 截取列表内容注意起始和结束位置、区间用 : 表示

用列表创建二维数组

• 这应该是列表嵌套的效果

x = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] <class 'list'>

print(x[1][2])
# 6

添加列表元素

语句	操作
list.append(obj)	在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.insert(index, obj)	在编号 index 位置插入 obj ，原有元素后移。

删除列表元素

语句	操作
list.remove(obj)	移除列表中某个值的第一个匹配项
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
del	删除已知位置的元素,可以删除整个列表

例：

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y)  # Friday

y = x.pop(0)
print(y)  # Monday

y = x.pop(-2)
print(y)  # Wednesday
print(x)  # ['Tuesday', 'Thursday']

获取列表中的元素

• 利用索引值( x[1:] 输出输出从第二个元素开始后的所有元素）

• 切片——Python中符合序列的有序序列都支持切片（slice）

• 切片常用写法 start : stop : step

• start:起始索引，从0开始，-1表示结束

• end：结束索引

• step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值

a=[1,2,3,4,5,6]
b1=a[:] #省略全部，代表截取全部内容，可以用来将一个列表拷给另一个列表（**浅拷贝**）

print(b1)
#[1, 2, 3, 4, 5, 6]

b=a[0:-1:1] #从位置0开始到结束，每次增加1，截取。不包含结束索引位置
print(b)
#[1, 2, 3, 4, 5]
c1=a[:3] #省略起始位置的索引，以及步长。默认起始位置从头开始，默认步长为1，结束位置索引为3
print(c1)
#[1, 2, 3]

c=a[0:5:3] #从第一个位置到第6个位置，每3个取一个值
print(c)
结果：[1, 4]

d=a[5:0:-1] #step设置为-1  反向取值
print(d)
结果：[6, 5, 4, 3, 2]

d1=a[::-1]
print(d1)
结果：[6, 5, 4, 3, 2, 1]

列表的常用操作符

表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
3 not in [1, 2, 3]	False	元素是否不存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代
[1,2,3] == [3,2,1]	False	成员、成员位置都相同时返回True

其他方法

• len(list) 列表元素个数
• max(list) 返回列表元素最大值
• min(list) 返回列表元素最小值
• list(seq) 将元组转换为列表
• list.count(obj) 统计某个元素在列表中出现的次数
• list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
• list.reverse() 反向列表中元素
• list.sort(key=None, reverse=False) 对原列表进行排序。
  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
  • 该方法没有返回值，但是会对列表的对象进行排序。

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]


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)]

练习题

• 题干链接见底部
• 列表操作练习

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

lst.append(15)#在列表的末尾增加元素15
print(lst)

lst.insert(5,20)#在列表的中间位置插入元素20
print(lst)

lst.extend([2, 5, 6])#将列表[2, 5, 6]合并到lst中
print(lst)

del lst[3]#移除列表中索引为3的元素
print(lst)

lst.reverse()#翻转列表里的所有元素
print(lst)

lst.sort(reverse=True)#降序
print(lst)

lst.sort(reverse=False)#升序
print(lst)



#[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
#[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
#[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
#[2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
#[6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
#[20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
#[2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]

• 修改列表

lst = [1, [4, 6], True] #将列表里所有数字修改成原来的两倍

• 这时候 让我挠了半天头 有趣的事请发生了！！！
  注意到如果对bool类型的判断写在后面，那个True会先经过一次对int的计算！！！后续我对那个2进行了一次type，结果2的类型还是bool，真是amazing啊
  Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
• leetcode 852题 山脉数组的峰顶索引

#直接用函数找出最大值下标返回
class Solution:
    def peakIndexInMountainArray(self, arr: List[int]) -> int:
        return arr.index(max(arr))
       

元组（tuple）

• 定义语法为：(元素1, 元素2, …, 元素n) （小括号注意与列表的中括号区分）
• 与列表类似，不同之处在于tuple被创建后就不能对其进行修改。
• 与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。
• 创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
• 二维元组与二维列表类似，使用元组嵌套

更新和删除一个元组

• 元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。
• 只能用del删除整个元组

#元组中包含可修改的变量，该变量的值可修改的意思呗
t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

元组相关的操作符

• 同列表

内置方法

• 元组大小和内容都不可更改，因此只有 count 和 index 两种方法（操作同列表）

解压（unpack）元组

• 个人理解按元组内格式来

练习题

• 元组概念

• 写出下面代码的执行结果和最终结果的类型

(1, 2)*2
(1, )*2
(1)*2     #此处括号为运算符

(1, 2, 1 , 2)   tuple
(1, 1)          tuple
2               int 

• Q:拆包过程是什么？
• A:拆包: 对于函数中的多个返回数据, 去掉元组, 列表 或者字典 直接获取里面数据的过程。参考
• Q:a, b = 1, 2 是拆包吗？
• A:不是，这是赋值
• Q:可迭代对象拆包时，怎么赋值给占位符？
• A:利用通配符 * 参考

字符串

• Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
• 类似于元组具有不可修改性

字符串的切片与拼接

• 切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。
• 索引值与列表、元组一样
  例：

str1 = 'I Love RM'
print(str1[:6])  # I Love
print(str1[5])  # e
print(str1[:6] + " 插入的字符串 " + str1[6:])  
# I Love 插入的字符串  RM

s = 'Python'
print(s)  # Python
print(s[2:4])  # th
print(s[-5:-2])  # yth
print(s[2])  # t
print(s[-1])  # n

常用内置方法

• 好多先码上
  案例

方法	描述
capitalize()	将字符串的第一个字符转换为大写。
lower()	转换字符串中所有大写字符为小写。
upper()	转换字符串中所有小写字母为大写。
swapcase()	将字符串中大写转换为小写，小写转换为大写。
count(str, beg= 0,end=len(string))	返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。
endswith(suffix, beg=0, end=len(string))	检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith(substr, beg=0,end=len(string))	检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string))	类似于 find() 函数，不过是从右边开始查找。
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
ljust(width[, fillchar])	返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
rjust(width[, fillchar])	返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。
lstrip([chars])	截掉字符串左边的空格或指定字符。
rstrip([chars])	删除字符串末尾的空格或指定字符。
strip([chars])	在字符串上执行lstrip()和rstrip()。
partition(sub)	找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回(‘原字符串’,’’,’’)。
rpartition(sub)	类似于partition()方法，不过是从右边开始查找。
replace(old, new [, max])	将字符串中的old替换成new，如果max指定，则替换不超过max次。
split(str="", num)	不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表
splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符
maketrans(intab, outtab)	创建字符映射的转换表，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
translate(table, deletechars="")	根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

• 看完一遍了（头秃）

字符串格式化

• format 格式化函数
  例：

str8 = "{0} Love {1}".format('I', 'RM')  # 位置参数
print(str8)  # I Love RM

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

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

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小数点后两位
print(str8)  # 27.66GB

Python 字符串格式化符号

• 同c语言的占位符类似但有区别

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串，用str()方法处理对象
%r	格式化字符串，用rper()方法处理对象
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	根据值的大小决定使用%f或%e
%G	作用同%g，根据值的大小决定使用%f或%E

• 格式化操作符辅助指令(加在 % 之后）

符号	功能
m.n	m 是显示的最小总宽度,n 是小数点后的位数（如果可用的话）
-	用作左对齐
+	在正数前面显示加号( + )
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格

练习题

1、 字符串函数回顾

• Q: 怎么批量替换字符串中的元素？
• A:使用replace（old, new)
• Q:怎么把字符串按照空格进⾏拆分？
• A:使用split()
• Q:怎么去除字符串⾸位的空格？
• A:使用lstrip()
  2、实现isdigit函数

    """
    判断字符串只包含数字
    :param string:
    :return:
    """
    def isdigit(string):
    for i, j in enumerate(string):
        if j >= '0' and j <= '9':
            continue
        else:
            return False
    return True
	string = input()
	print(isdigit(string))

3、leetcode 5题 最长回文子串

• 本想将原字符串反向比较两个字符串的最长公共子串，没想如果是aacadefacaa这样的会输出aaca
• 然后暴力解法成功超时
• 学了一下马拉车算法Manacher算法
• 个人观感是对中心检测法的回文半径方面做出优化

'''
String:加'#'处理后的回文串
MaxR:最长回文半径
flag:最长回文半径对应的中心点下标
i_R[i]:以i为中心对应的回文半径
'''
class Solution:
    def longestPalindrome(self, s: str) -> str:
        s = '#' + '#'.join(s) + '#' #插入符号使得字符串一定为奇数
        lenth = len(s)
        MaxR = 0
        flag = 0
        i_R = [0] * lenth
        for i in range(lenth):
            if MaxR > i:
                i_R[i] = min(MaxR - i, i_R[int(2 * flag - i)])   #2*flag-i是i点关于flag的对称点
            else:
                i_R[i] = 1
            while i - i_R[i] >= 0 and i + i_R[i] < lenth and s[i - i_R[i]] == s[i + i_R[i]]:
                i_R[i] += 1
            if i + i_R[i] > MaxR:
                MaxR = i + i_R[i]
                flag = i
        i_res = i_R.index(max(i_R)) # 获取最长子串中心位置
        s3 = s[i_res - (i_R[i_res] - 1) : i_res + i_R[i_res]]#获取最长子串
        s_res = s3.replace('#', '')#删去插入的 #
        return s_res

Day5：字典、集合和序列

可变类型与不可变类型

• 可变类型（mutable）：列表，字典

• 不可变类型（unmutable）：数字，字符串，元组

• 这里的可变不可变，是指内存中的那块内容（value）是否可以被改变

• 判断方法

• 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。

• 便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。

字典（dict）

• 定义：字典是另一种可变容器模型，且可存储任意类型对象。

• 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

• d = {key1 : value1, key2 : value2, key3 : value3 }

• 如果我们取的键在字典中不存在，会直接报错KeyError。

创建字典

• 通过构造函数dict来创建字典。
  例

#通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入 value，后面的值会把前面的值冲掉。

dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3

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

dic['a'] = 11
print(dic)
# {'a': 11, 'b': 2, 'c': 3}

dic['d'] = 4
print(dic)
# {'a': 11, 'b': 2, 'c': 3, 'd': 4}


# 映射对象的(key，value)初始化新字典
dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1)  # {'apple': 4139, 'peach': 4127, 'cherry': 4098}

dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2)  # {'apple': 4139, 'peach': 4127, 'cherry': 4098}


# 用关键字 name=value 初始化新字典。(1=1，2=2)
# 这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。
dic = dict(name='Tom', age=10)
print(dic)  # {'name': 'Tom', 'age': 10}
print(type(dic))  # <class 'dict'>

内置方法

• 链接

练习题

1、字典基本操作（用程序解答）
dic = { 'python': 95, 'java': 99, 'c': 100 }

#字典的长度是多少
print(len(dic))
#请修改'java' 这个key对应的value值为98
dic['java'] = 98
#删除 c 这个key
del dict['Name']
#增加一个key-value对，key值为 php, value是90
dic['php'] = 90
#获取所有的key值，存储在列表里
keys = list(dic.keys())
#获取所有的value值，存储在列表里
values = list(dic.values())
#判断 javascript 是否在字典中
dic.get('javascript',"NA")
#获得字典里所有value 的和
sum = sum(values)
#获取字典里最大的value
Max = max(values)
#获取字典里最小的value
Min = min(values)
#字典 dic1 = {'php': 97}， 将dic1的数据更新到dic中
dic.update(dic1)

2、字典中的value

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

data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}]
        }
各门课程的考试成绩存储方式并不相同，有的用字典，有的用列表，但是分数都是字符串类型，请实现函数transfer_score(score_dict)，将分数修改成int类型

def transfer_score(data):
    for key, value in data.items(): #以列表取得key 和 value
        if isinstance(value, dict):
           	for k, v in value.items():
               	data[key][k] = int(data[key][k])
       	elif isinstance(value[0], str):
           	for i in range(len(value)):
               	data[key][i] = int(data[key][i])
       	else:
           	for k, v in value[0].items():
               	data[key][0][k] = int(data[key][0][k])
        return data

集合（set）

• Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
  注意：
• key为不可变类型，即可哈希的值。
• 集合是无序的-> 不支持下标索引或切片操作
• 集合（set）是可变的数据类型
• 集合中的元素是唯一的
• 集合一般用于元组或者列表中的元素去重
  点此开始学习 （#狗头）

练习题

# 表示只包含⼀个数字1的元组。
s1 = {1}
# 创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。
s2 = set()
s2.add('x')
s2.add('y')
s2.add('z')
# 列表['A', 'B', 'A', 'B']去重。
s3 = set(['A', 'B', 'A', 'B'])
# 求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。
s4 = {6, 7, 8} ^ {7, 8, 9} #差集结果为6
# 求{'A', 'B', 'C'}中元素在 {'B', 'C', 'D'}中出现的次数。
count = len({'A', 'B', 'C'} & {'B', 'C', 'D'})

注意

• Python中的差集和数学上的差集不同！！！
• 数学上：差集指的是两个集合交集外的部分
• Python中：个人定义 差集是被减集合除去两个集合交集外的部分（求出前一个集合独有部分）——————这就会导致 a - b 与 b - a 结果不同

序列

• 在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
  

练习题

#怎么找出序列中的最⼤、⼩值？
max() 和 min()
#sort() 和 sorted() 区别
一个有ed一个没有（不是
1、sort是应用在list上的，而sorted可应用于任何可迭代的对象上；

2、list的sort方法是在原始list上操作，而sorted返回新的list；

3、sort使用ls.sort()，而sorted使用sorted(ls);
#怎么快速求 1 到 100 所有整数相加之和？
Sum = sum(range(101))
#求列表 [2,3,4,5] 中每个元素的立方根。
lis=[2,3,4,5] 
for i in range(0,len(lis)):
     lis[i] = lis[i] ** 3
#将[‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。
a = ['x','y','z'] 
b = [1,2,3]
zipped = zip(a, b)#用zip（）打包