python元组 字符串 字典 习题+总结

概念

a_tuple = {’ crazyit ’, 20 , 5 . 6,’f kit ’,-17)
＃访问倒数第1 个元素
print (a_tuple ［-1]) # - 17
＃访问倒数第2 个元素
print(a_tuple[-2]) # - fkit

特殊运算符

python中有特殊运算符
in 运算符
in 运算符用于判断列表或元组是否包含某个元素

Python 提供了内置的ten（）、max（）、min（）全局函数来获取元组或列表的长度、最大值和最小值。
由于max（）、min（）要对元组、列表中的元素比较大小，因此程序要求传给max （）、min （）函数的元组、列表的元素必须是相同类型且可以比较大小。

封包和拆包

Python 还提供了序列封包（ Sequence Packing ）和序列解包（ Sequence Unpacking ）的功能。程序把多个值赋给一个变量时， Python 会自动将多个值封装成元组。这种功能被称为序列封包。
程序允许将序列（元组或列表等）直接赋值给多个变量，此时序列的各元素会被依次赋值给每个变量（要求序列的元素个数和变量个数相等）。这种功能被称为序列解包。

元组练习题

1、元组概念

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

(1, 2)*2
(1, )*2
(1)2
分析为什么会出现这样的结果.
----因为元组的乘法与单个数字乘法不同，并不会将数值进行乘积，而且将整体变化，如一个元组2以后变成一个含有双倍数量元素的元组

通过索引输出:

ttu=(‘cra’,‘he’,‘zi’,423,11,23)
print(ttu[1:3])
(‘he’, ‘zi’)

2、拆包过程是什么？
----示例：

vals = 10 , 20 , 30
print(vals)
(10, 20, 30)

a, b = 1, 2
上述过程属于拆包吗？
—不属于

可迭代对象拆包时，怎么赋值给占位符？
赋给单个对象算不算拆包？
还不清楚如果元组中有数字又有字符串时占位符怎么用，试了一下字符串：

 ni = ('he','ziii','yi','mutai','danshen','wurenchaoguo')
    for i in ni:
        print('%s'%(i),end=" ")

输出：
he ziii yi mutai danshen wurenchaoguo
Process finished with exit code 0

if __name__ == '__main__':
    nice=('hehe','liang','boy','ooo')
    nice = nice+divmod(55,2)
    print(nice)
    for i in nice:
        print(i)

输出:
(‘hehe’, ‘liang’, ‘boy’, ‘ooo’, 27, 1)
hehe
liang
boy
ooo
27
1

拆包:

＃序列解包： 将a_tuple 元组的各元素依次赋值给a 、b 、c 、d、e 变量
a , b , c , d , e = a tuple
print (a, b , c , d , e)

先封包再解包：

python一种输出类似C语言中printf("%s"):

nice=input(“请输入:”)
请输入:静静

print(‘nice is %s:’%(nice))
nice is 静静:

一个很特别的点：在序列解包时也可以只解出部分变量，剩下的依然使用列表变量保存。为了使用这种解包方式，
Python 允许在左边被赋值的变量之前添加“＊”，那么该变量就代表一个列表，可以保存多个集合
元素。

  first, second, *rest = range (10)
    print(first)  # 0
    print(second)  # 1
    print(rest)  # [2 , 3 , 4 , 5 , 6 , 7 , 8 , 9)

Process finished with exit code 0

字符串

字符串的切片与拼接
类似于元组具有不可修改性
切片通常写成 start:end 这种形式，包括「start 索引」对应的元素，不包括「end索引」对应的元素。
python中有一个特殊点:负索引（c++中无)
索引值可正可负，正索引从 0 开始，从左往右；负索引从 -1 开始，从右往左。使用负数索引时，会从最后一个元素开始计数。最后一个元素的位置编号是 -1。

例子:

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

. 字符串的常用内置方法

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、字符串函数回顾

怎么批量替换字符串中的元素？
怎么把字符串按照空格进⾏拆分？
怎么去除字符串⾸位的空格？
以上功能实现代码:

if __name__ == '__main__':
    name = "heziyi"
    name = name.replace('yi','wow')
    print(name)
    nam2 = 'lllziyi jin tian zhen'
    print(nam2.split())
    name3 = '  今天是好日子'
    name3 = name3.lstrip()
    print(name3)

结果:

2、实现isdigit函数

题目要求

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

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

代码:

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 = "heziyi"
    print(isdigit(name))
    num = '1234423'
    print(isdigit(num))

结果：

3、leetcode 5题 最长回文子串

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

示例:

输入: “babad”

输出: “bab”

输入: “cbbd”

输出: “bb”

力扣中等难度的题。。。。我承认我现在事情有点多的情况下没法安分地去思考这个题。。。。一开始想到先定义函数求出一个是回文子串的串长度，然后在main中可以循环来判断所有子串长度的最大值，输出长度最大的串然后写出来的一直好像有问题，官方题解看了一下，之前都不知道原来可以return两个值，python中的语法还真是很随意。
在pycharm里面跑了一下这个：

def expandAroundCenter( s, left, right):
        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return left+1, right-1


def biggest(string):
    len1 = len(string)
    start = 0
    end = 0
    i = 0
    for i in range(len1):
        if i+1>len1:
            break
        max1,max2 = expandAroundCenter(string,i,i)
        max3,max4 = expandAroundCenter(string,i,i+1)
        if max2 - max1 > max4 - max3:
            start,end = max1,max2
        else:
            start,end = max3,max4

    return string[int(start),int(end+1)]

class Solution:
   def longestPalindrome(self, s: str) -> str:
          
    # your code here

结果还是typeerror:

File “C:\Users\14172\PycharmProjects\pythonProject3\main.py”, line 40, in
print(biggest(st))
File “C:\Users\14172\PycharmProjects\pythonProject3\main.py”, line 36, in biggest
return string[int(start),int(end+1)]
TypeError: string indices must be integers

Process finished with exit code 1

手头还有好多别的事，这个问题回头再来看吧。。。感觉应该是语法错误吧。。。

字典

程序既可使用花括号语法来创建字典，也可使用dict（） 函数来创建字典。

在使用花括号语法创建字典时，花括号中应包含多个key-value 对， key 与value 之间用英文冒号隔开；多个key-value 对之间用英文逗号隔开。

直接print()括号中为元组的名字时原样输出:

    scores = {'chinese': 89,'math': 92 ,'english': 93}
    print(scores)
    # 空的花括号代表空的diet
    empty_dict = {}
    print(empty_dict)
    #使用元组作为diet的key
    dict2 = {(20, 30): 'good ’ , 30 :’ bad'}
    print(dict2)

结果：
{‘chinese’: 89, ‘math’: 92, ‘english’: 93}
{}
{(20, 30): ‘good ’ , 30 :’ bad’}

Process finished with exit code 0

• 注意：
  元组可以作为diet 的key，但列表不能作为元组的key这是由于diet 要求key必须是不可变类型，但列表是可变类型，因此列表不能作为元组的key 。

在使用diet（）函数创建字典时， 可以传入多个列表或元组参数作为key-value 对， 每个列表或元组将被当成一个key-value 对，因此这些列表或元组都只能包含两个元素。

示例:

vegetables =[('name','何梓贻') ,('gender','girl') ,('age',19)]
    vet3 = dict(vegetables)
    print(vet3)
    fruit=[['name','何梓贻'],['gender','girl']]
    vet2 = dict(fruit)
    print(vet2)

输出：
{‘name’: ‘何梓贻’, ‘gender’: ‘girl’, ‘age’: 19}
{‘name’: ‘何梓贻’, ‘gender’: ‘girl’}
还可通过为diet 指定关键字参数创建字典，此时字典的key 不允许使用表达式：

dict4 = dict (name=‘何梓贻’,age=19)
print(dict4)
{‘name’: ‘何梓贻’, ‘age’: 19}

操作字典

1.如果要为diet 添加key-value 对，只需为不存在的key 赋值即可
＃对不存在的key 赋值，就是增加key - value 对
scores [‘数学’]= 93
2.如果要删除宇典中的key- value 对，则可使用del 语句。例如如下代码
＃使用del i吾句删除key - value 对
del scores [‘数学’]
3.如果对diet 中存在的key-value 对赋值，新赋的value巳就会覆盖原有的value ， 这样即可改变diet中的key-value 对
4.如果要判断字典是否包含指定的key ，则可以使用in 或not in 运算符，对于dict 而言，in或not in 运算符都是基于key 来判断的
5.＃清空cars 的所有key-value 对
cars . clear ()
6.get()方法其实就是根据key 来获取value ， 它相当于方括号语法的增强版当使用方括号语法访问并不存在的key 时，字典会引发KeyError 错误

fruit=[['name','张三'],['gender','girl']]
    vet2 = dict(fruit)
    print(vet2.get('name'))

输出张三

7.items（）、keys()、values()分别用于获取字典中的所有key-value 对、所有key、所有value 。这三个方法依次返回diet-items 、diet keys 和diet_values 对象， Python 不希望用户直接操作这几个方法，但可通过list（）函数把它们转换成列表。
总结:字典的key 是它的关键。换个角度来看，字典的k巳y 就相当于它的索引，只不过这些索引不一定是整数类型，字典的key 可以是任意不可变类型。

fruit=[['name','李四'],['gender','girl']]
    vet2 = dict(fruit)
    itm = vet2.items()
    print(itm)
    print(list(itm))

输出:
dict_items([(‘name’, ‘李四’), (‘gender’, ‘girl’)])
[(‘name’, ‘李四’), (‘gender’, ‘girl’)]

itm = vet2.values()
    print(itm)
    print(list(itm))

输出：
dict_values([‘李四’, ‘girl’])
[‘李四’, ‘girl’]

8.updateO方法可使用一个字典所包含的key- value 对来更新己有的字典。在执行update（）方法时，如果被更新的字典中己包含对应的key-value 对， 那么原value 会被覆盖：如果被更新的字典中不包含对应的key-value 对， 则该key-value 对被添加进去

cars = {'name':'张三','age':19}
    cars.update({'name':'lisi'})
    print(cars)

输出:
{‘name’: ‘lisi’, ‘age’: 19}

9.pop（）方法用于获取指定key 对应的value ，并删除这个key- value 对。如下方法示范了pop （）方法的用法。
10.popitem（）方法用于随机弹出字典中的一个key-value对。

• 注：
  实际上字典的popitem（）是弹出字典中最后一个键值对由于字典存储key-value 对的顺序是不可知的，因此开发者感觉字典的popitem（）方法是“随机”弹出的，但实际上字典的popitem（）方法总是弹出底层存储的最后一个key-value 对
• 注意：
  列表不允许对不存在的索引赋值；但字典则允许直接对不存在的key 赋值。

字典的常用方法:
在交互式解释器中输入dir：

dir(dict)
[‘class’, ‘class_getitem’, ‘contains’, ‘delattr’, ‘delitem’, ‘dir’, ‘doc’, ‘eq’, ‘format’, ‘ge’, ‘getattribute’
, ‘getitem’, ‘gt’, ‘hash’, ‘init’, ‘init_subclass’, ‘ior’, ‘iter’, ‘le’, ‘len’, ‘lt’, ‘ne’, ‘new’, ‘or’
, ‘reduce’, ‘reduce_ex’, ‘repr’, ‘reversed’, ‘ror’, ‘setattr’, ‘setitem’, ‘sizeof’, ‘str’, ‘subclasshook’, ‘clear’,
‘copy’, ‘fromkeys’, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’]

字典嵌套

在字典中存储列表
习题中第二题c++即嵌套了列表

data = {
‘python’: {‘上学期’: ‘90’, ‘下学期’: ‘95’},
‘c++’: [‘95’, ‘96’, ‘97’],
‘java’: [{‘月考’: ‘90’, ‘期中考试’: ‘94’, ‘期末考试’: ‘98’}]
}

在字典中存储字典
例子：

 grade={
       'score': {
            '语文':99,'math':88,'pe':100
        },
        'information':
            {
            'name':'何梓贻','age':19
        }
    }
        for gras1,gras2 in grade.items():
        print(gras1)
        print(gras2)

输出：
score
{‘语文’: 99, ‘math’: 88, ‘pe’: 100}
information
{‘name’: ‘何梓贻’, ‘age’: 19}

若 print(list(gras2.values())[1])
输出19

其中grade中包含两个键，每个与键相关联的值都是一个字典

字典练习题

：

1、字典基本操作

字典内容如下:

dic = {
‘python’: 95,
‘java’: 99,
‘c’: 100
}
用程序解答下面的题目

字典的长度是多少
请修改’java’ 这个key对应的value值为98
删除 c 这个key
增加一个key-value对，key值为 php, value是90
获取所有的key值，存储在列表里
获取所有的value值，存储在列表里
判断 javascript 是否在字典中
获得字典里所有value 的和
获取字典里最大的value
获取字典里最小的value
字典 dic1 = {‘php’: 97}， 将dic1的数据更新到dic中

dic = {
        'python': 95,
        'java': 99,
        'c': 100
    }
    print(len(dic))
    del(dic['java'])
    print(dic)
    dic['php']=90
    print(list(dic.keys()))
    print(list(dic.values()))
    print('javascript' in dic)
    print('min:'+min(dic)+'max:'+max(dic))
    dic['php']=97
    print(dic)

结果：

2、字典中的value

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

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

def transfer_score(data):
# your code here

代码:

def transfer_score(dataa):
    dataa = int(dataa)
    return dataa


if __name__ == '__main__':
    data = {
        'python': {'上学期': '90', '下学期': '95'},
        'c++': ['95', '96', '97'],
        'java': [{'月考': '90', '期中考试': '94', '期末考试': '98'}]
    }
    data1 = list(data.values());
    print(data1)
    print(data1[0])
    print(data1[1])
    print(data1[2][0])
    for i in range(len(data1[0])):
     list(data1[0].values())[i] = transfer_score(list(data1[0].values())[i])
     print(list(data1[0].values())[i],end=" ")
    print('\n')
    for i in range(len(data1[1])):
       data1[1][i] = transfer_score(data1[1][i])
       print(data1[1][i], end=" ")
    print('\n')
    for i in range(len(data1[2][0])):
        list(data1[2][0].values())[i] = transfer_score(list(data1[2][0].values())[i])
        print(list(data1[2][0].values())[i], end=" ")

结果：

一些思考:感觉写的有点冗长，主要是拆包部分，但由于data中三个数据类型不一样，不好用一个统一的循环进行拆，于是只能一个一个拆

一些其他的总结

创建类：

class Person:
  def __init__(self, name):
    self.name = name
  def getName(self):
    return self.name
  def color(self, color):
    print "%s is %s" % (self.name, color)

def__init__叫作初始化函数（因为还有一个__new__的函数是
真正的构造。所以，将__init__称之为初始化函数）。

divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

一些转化类型的函数

python中的字符数字之间的转换函数

int(x [,base ]) 将x转换为一个整数
★★★int()函数可以把数字字符串转化成int类型的数字,但是不能传入非数字的字符串
long(x [,base ]) 将x转换为一个长整数

float(x ) 将x转换到一个浮点数

complex(real [,imag ]) 创建一个复数

str(x ) 将对象 x 转换为字符串

repr(x ) 将对象 x 转换为表达式字符串

eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s ) 将序列 s 转换为一个元组

list(s ) 将序列 s 转换为一个列表

chr(x ) 将一个整数转换为一个字符

unichr(x ) 将一个整数转换为Unicode字符

ord(x ) 将一个字符转换为它的整数值

hex(x ) 将一个整数转换为一个十六进制字符串

oct(x ) 将一个整数转换为一个八进制字符串

chr(65)=‘A’

ord(‘A’)=65