python学习

最新推荐文章于 2023-05-25 06:17:56 发布

未来～可期

最新推荐文章于 2023-05-25 06:17:56 发布

阅读量319

点赞数

文章标签： python

本文链接：https://blog.csdn.net/qq_51562121/article/details/113324921

版权

异常处理

一些异常处理的说明

一些需要记住的例子

dict1 = {'a': 1, 'b': 2, 'v': 22}
try:
    x = dict1['y']
except LookupError:
    print('查询错误')
except KeyError:
    print('键错误')
else:
    print(x)

 查询错误

try-except-else语句尝试查询不在dict中的键值对，从而引发了异常。这一异常准确地说应属于KeyError，但由于KeyError是LookupError的子类，且将LookupError置于KeyError之前，因此程序优先执行该except代码块。所以，使用多个except代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。
如果在try子句执行时没有发生异常，Python将执行else语句后的语句。
else语句的存在必须以except语句的存在为前提，在没有except语句的try语句中使用else语句，会引发语法错误。就是try except else成分不能缺少。
Python 使用raise语句抛出一个指定的异常。

【例子】

try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
    
 An exception flew by!

1、猜数字游戏

题目描述:

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

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

获取随机数采用random模块。

补充

random模块需要导入，所以使用前要先写入import random。
random函数
其中对于这题我们用到：random.randint
random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b。
（except后面的print里面用单引号）

# coding=gbk
from typing import List
import random
print("there is a numble from 0 to 100 in my heart, you need guess it")
numble = random.randint(0, 100)

try:
    guess=int(input())
except ValueError as error:
    print('输入无效')
a=0
while guess!=numble:
    a+=1
    print("第%d次猜测"%a)
    if guess>100:
        print("invalid numble,please again")
        guess = int(input())
    elif guess<0:
        print("invalid numble,please again")
        guess = int(input())
    else:
        if guess>numble:
            print("no,numble is small")
        else:
            print("no,numble is big")
        guess = int(input())
print("yes",numble)

列表、元组和字符串

一些需要记住的例子

x = [0] * 5
print(x, type(x))
 [0, 0, 0, 0, 0] <class 'list'>

x = [0 for i in range(5)]
print(x, type(x))
 [0, 0, 0, 0, 0] <class 'list'>

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

x = [i for i in range(1, 10, 2)]
print(x, type(x))
#[1, 3, 5, 7, 9] <class 'list'>

x = [i for i in range(10, 1, -2)]
print(x, type(x))
 [10, 8, 6, 4, 2] <class 'list'>

x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
 [1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>
 
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
 [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

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'>

for i in x:
    print(i, type(i))
 [1, 2, 3] <class 'list'>
 [4, 5, 6] <class 'list'>
 [7, 8, 9] <class 'list'>
 [0, 0, 0] <class 'list'>

x = [[0 for col in range(3)] for row in range(4)]
print(x, type(x))
 [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
 [[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x = [[0] * 3 for row in range(4)]
print(x, type(x))
 [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[1][1] = 1
print(x, type(x))
 [[0, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.remove(obj) 移除列表中某个值的第一个匹配项
list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
【例子】

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

remove 和 pop 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
切片的通用写法是 start : stop : step

x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0]))  # Monday <class 'str'>
print(x[-1], type(x[-1]))  # ['Thursday', 'Friday'] <class 'list'>
print(x[-2], type(x[-2]))  # Wednesday <class 'str'>

前面三种方法（append, extend, insert）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。
1、列表操作练习

列表lst 内容如下

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

请写程序完成下列操作：

在列表的末尾增加元素15
在列表的中间位置插入元素20
将列表[2, 5, 6]合并到lst中
移除列表中索引为3的元素
翻转列表里的所有元素
对列表里的元素进行排序，从小到大一次，从大到小一次

lst = [2,5,6,7,8,9,2,9,9]
lst.sort(reverse=True)
print(lst)
lst.sort(reverse=False)
print(lst)
lst.append(15)
print(lst)
lst[5:5] = [20]
print(lst)
lst.append([2,5,6])
print(lst)
a = lst.pop(3)
print(lst)
lst.reverse()
print(lst)

False True首字母大写

lst = [1, [4, 6], True]
lst1 = []
lst2 = []
for i in lst:
    if type(i) != list:
        i *= 2
        lst1.append(i)
    else:
        for elem in i:
            elem *= 2
            lst2.append(elem)
        lst1.append(lst2)
print(lst1)

lst = [1, 3, 4, 5, 3]
lst1 = [1, 2, 4, 6, 4, 5]

def peak(lst):
    len_lst = len(lst)
    if len_lst < 3:
        print('数组长度应该大于等于3')
        return
    max_e = max(lst)
    if lst.count(max_e) != 1:
        return print('False')
    
    max_index = lst.index(max_e)
    len_l, len_r = len(lst[:max_index]), len(lst[(max_index+1):])
    if len_l == 1:
        pass
    else:
        for i in range(len_l-1):
            if lst[i] >= lst[i+1]:
                return print('False')  
            
    if len_r == 1:
        pass
    else:
        for i in range(max_index+1, len(lst)-1):
            if lst[i] <= lst[i+1]:
                return print('False')
                    
    print('True')

元组

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
【例子】

x = (1)
print(type(x))  # <class 'int'>
x = 2, 3, 4, 5
print(type(x))  # <class 'tuple'>
x = []
print(type(x))  # <class 'list'>
x = ()
print(type(x))  # <class 'tuple'>
x = (1,)
print(type(x))  # <class 'tuple'>

练习题：

1、元组概念

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

(1, 2)*2
(1, )*2
(1)*2
分析为什么会出现这样的结果.
（1,2,1,2) (1,1) 1 1
因为元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
2、拆包过程是什么？
**拆包，是将一个序列类型的数据拆开为多个数据，分别赋值给变量，位置对应。
如：a,b,c=（‘A’,‘B’,‘C’），python解释器会将其拆包为,a=‘A’,b=‘B’,c=‘C’。

a, b = 1, 2
上述过程属于拆包吗？
我觉得不是，这不属于一个序列类型。
可迭代对象拆包时，怎么赋值给占位符？

字符串

一些需要记忆的
Python 中字符串被定义为引号之间的字符集合。
Python 支持使用成对的单引号或双引号。

print(5 + 8)  # 13
print('5' + '8')  # 58

lower() 转换字符串中所有大写字符为小写。
upper() 转换字符串中的小写字母为大写。
swapcase() 将字符串中大写转换为小写，小写转换为大写。
【例子】

str2 = "DAXIExiaoxie"
print(str2.lower())  # daxiexiaoxie
print(str2.upper())  # DAXIEXIAOXIE
print(str2.swapcase())  # daxieXIAOXIE

count(str, beg= 0,end=len(string)) 返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。
【例子】

str2 = "DAXIExiaoxie"
print(str2.count('xi'))  # 2

endswith(suffix, beg=0, end=len(string)) 检查字符串是否以指定子字符串 suffix 结束，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith(substr, beg=0,end=len(string)) 检查字符串是否以指定子字符串 substr 开头，如果是，返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
【例子】

str2 = "DAXIExiaoxie"
print(str2.endswith('ie'))  # True
print(str2.endswith('xi'))  # False
print(str2.startswith('Da'))  # False
print(str2.startswith('DA'))  # True

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

【例子】

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.'

总结

capitalize() 将字符串的第一个字符转换为大写。
print(str2.capitalize()) # Xiaoxie
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() 函数，不过是从右边开始查找。

习题

1、字符串函数回顾

怎么批量替换字符串中的元素？
怎么把字符串按照空格进⾏拆分？
怎么去除字符串⾸位的空格？
在这里插入图片描述

把将字符串中的old替换成new，如果max指定，则替换不超过max次。对次数max进行设置或多次调用replace函数就能实现批量替换元素。
使用split()
使用lstrip()
2、实现isdigit函数

题目要求

实现函数isdigit，判断字符串里是否只包含数字0~9

def isdigit(string):
“”"
判断字符串只包含数字
:param string:
:return:
“”"

 def isdigit(string):

    # your code here
    len1 = len(string)
    for i in range(len1):
        try:
            int(string[i])

        except ValueError:
            return False
    return True

if __name__ == '__main__':
    name = "leimingshenyi"
    print(isdigit(name))
    num = '1234423'
    print(isdigit(num))

3、leetcode 5题最长回文子串

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

示例:

输入: “babad”

输出: “bab”

输入: “cbbd”

输出: “bb”
难想不懂可以中等题了我还是太菜

class Solution:
   def longestPalindrome(self, s: str) -> str:
          
  class Solution:
def extend(s,start,end,k):
if (start<k or end+k>=len(s)):
return k-1
if s[start-k]==s[end+k]:
return extend(s,start,end,k+1)
else:
return k-1
def longestPalindrome(self, s: str) -> str:
c=’’
l=len(s)-1
if l<1:
return s
L=0
tar=s[0]
for i in range(l):
if s[i]==s[i+1]:
sl=extend(s,i,i+1,0)
if 2sl+2>=L:
L=2sl+2
tar=s[i-sl:i+sl+2]
if s[i-1]==s[i+1]:
if i<1:
continue
sl=extend(s,i-1,i+1,1)
if 2sl+3>=L:
L=2sl+3
tar=s[i-sl-1:i+sl+2]
return tar

未来～可期

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python学习

异常处理一些异常处理的说明一些需要记住的例子dict1 = {'a': 1, 'b': 2, 'v': 22}try: x = dict1['y']except LookupError: print('查询错误')except KeyError: print('键错误')else: print(x) 查询错误try-except-else语句尝试查询不在dict中的键值对，从而引发了异常。这一异常准确地说应属于KeyError，但由于KeyError是L
复制链接

扫一扫