【小甲鱼】python零基础入门学习笔记 03讲~43讲

本篇基于【莫烦】python基础教程，属于查漏补缺
建议学习顺序 小甲鱼->莫烦numpy&pandas

第003讲 插曲之变量和字符串

课堂笔记

变量

• 变量名就像我们现实社会的名字，把一个值赋值给一个名字时，TA会存储在内容中，称之为变量（variable），在大多数语言中，都把这种行为称为“给变量赋值”或“把值存储在变量中”。
• 不过python与大多数其他计算机语言的做法稍有不同，Ta并不是把值存储在变量中，而更像是把名字贴在值的上面。
• 所以有些python程序员会说“python”没有“变量”，只有“名字”。

变量 需要注意的地方

• 在使用变量之前，需要对其先赋值
• 变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
• 大小写敏感，字母可以是大写或小写，但大小写是不同的。也就是说Fish和fish对python来说是完全不同的两个名字。
• 等号（=）是赋值的意思，左边是名字，右边是值，不可写反。
• 变量的命名理论可以取任何合法的名字，但作为一个优秀的程序员，请尽量给变量取一个专业一点儿的名字

字符串

• 到目前为止，我们所认识的字符串就是引号内的一切东西，我们也把字符串叫做文本，文本和数字是截然不同的

>>>5+8
13
>>>'5'+'8'
'58'

• 要告诉python你在创建一个字符串，就要在字符两边加上引号，可以是单引号或者双引号，但必须成对，不能一边单一边双。
• 想要打印单引号（双引号），需要使用转义符（\）进行转义，或者外层使用双引号（单引号）

>>>"Let's go!"
>>>>'Let\'s go!'

原始字符串

• 我们可以用反斜杠对自身进行转义
• 如果一个字符串中有很多个反斜杠，手动添加会很麻烦
• 原始字符串的使用使之非常简单，只需要在字符串前加一个英文字母r即可：
  python 3.6之后又发生了变化 非bulitin字符会自动添加反斜杠
• 如果希望得到一个跨越多行的字符串，需要使用三重引号字符串（’‘‘balabala’‘’）同样，单引号与双引号需要成对出现，在IDLE中使用CTRL+j换行，直接打印换行符会变成\n，print（）就能正常显示换行后的效果

>>> a='''白日依山尽，
黄河入海流。
欲穷千里目，
更上一层楼。'''
>>> print(a)
白日依山尽，
黄河入海流。
欲穷千里目，
更上一层楼。
>>> a
'白日依山尽，\n黄河入海流。\n欲穷千里目，\n更上一层楼。'

课后练习

3. 在不上机的情况下，以下代码你能猜到屏幕会打印什么内容吗？

>>first = 520
>>second = '520'
>>first = second
>>print(first)

会打印：520，注：这里没有单引号括起来，但是他是一个字符串，因为使用 print() 打印，所以不包含单引号。可以试试直接>>>first，它是一个字符串的。

5. 如果非要在原始字符串结尾输入反斜杠，可以如何灵活处理？

>>>str = r'C:\Program Files\FishC\Good''\\'

6. 在这一讲中，我们说变量的命名需要注意一些地方，但小甲鱼在举例的时候貌似却干了点儿“失误”的事儿，你能看得出小甲鱼例子中哪里有问题吗？

Python 貌似不介意我们对内置函数进行赋值操作，所以这点我们以后就要注意啦，否则可能会出现以下的 BUG：

>>> print = 1
>>> print("I love FishC")
Traceback (most recent call last):
 File "<pyshell#37>", line 1, in <module>
   print("I love FishC")
TypeError: 'int' object is not callable

第004讲 改进我的小游戏

课后练习

3. Python3 中，一行可以书写多个语句吗？

可以，语句之间用分号;隔开即可，如：

>>> print("我爱你");print("你也爱我")
我爱你
你也爱我

4. Python3 中，一个语句可以分成多行书写吗？

可以，一行过长的语句可以使用反斜杠或者括号分解成几行，如：

>>> 3 > 4 and \
    1 < 2
False

或者：

>>> (3 > 4 and
     1 < 2)
False

5. 【该题针对有C或C++基础的朋友】请问Python的 and 操作符 和C语言的 && 操作符 有何不同？

没什么不同，就是长得不一样。

用C语言，判断语句这么写：if( x==1 && y==2 )；用Python，只能这么写：if x==1 and y==2:

6. 听说过“短路逻辑（short-circuit logic）”吗？

逻辑操作符有个有趣的特性：在不需要求值的时候不进行操作。这么说可能比较“高深”,即 ‘不做无用功’ 。如，表达式 x and y，需要 x 和 y 两个变量同时为真(True)的时候，结果才为真。 因此，如果当 x 变量得知是假(False)的时候，表达式就会立刻返回 False，而不用去管 y 变量的值。 这种行为被称为短路逻辑（short-circuit logic）或者惰性求值（lazy evaluation）。
动动手习题及答案：

动动手
0. 完善第二个改进要求（为用户提供三次机会尝试，机会用完或者用户猜中答案均退出循环）并改进视频中小甲鱼的代码。

import random

secret = random.randint(1,10)
guess = 0
count = 3
print("----------START------------")
while guess != secret and count > 0:
    print("All 3 chances,and you still have",count,"chances")
    temp = input("Please enter a number(1~10):")
    guess = int(temp)
    count = count - 1
    if guess == secret:
        print("wonderfully congraduation!")
    else:
        if guess > secret:
            print("you guess gigger!")
        else:
            print("you guess smaller!")
        if count > 0:
            print("you have chance,you can continue!")
        else:
            print("No chance,byebye!")
print("Game over!")

第005讲 闲聊之python的数据类型

课堂笔记

• 变量没有数据类型，python有
• 字符串的相加为拼接，数字的相加得到和

python的一些数值类型

整型 int

python2分为整型和长整型，python3 后大小只受虚拟内存限制

浮点型 float

与整型的区别在于有没有小数点

布尔类型 bool

特殊的整型，TRUE相当于1，FALSE相当于0，可以进行四则运算，但不推荐这么做

e记法（科学记数法）

为浮点型

>>>1e-2
0.01

类型转换

整数 int(x)

• 不能出现中文、英文等非数字
• 浮点数转化为整型采取截断处理 int(5.99)=5

字符串 str()

浮点数 float()

整数转浮点数默认产生一位小数 float（1）=1.0

获取关于类型的信息

• type() 返回函数的类型
  -** isinstance(object, classinfo) **函数来判断一个对象是否是一个已知的类型
  object – 实例对象。
  classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
  返回值
  如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。

class A:
    pass
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B())             # returns B

如果要判断两个类型是否相同推荐使用 isinstance()。

判断函数

x.isalnum() 所有字符都是数字或者字母，为真返回 Ture，否则返回 False。
x.isalpha() 所有字符都是字母，为真返回 Ture，否则返回 False。
x.isdigit() 所有字符都是数字，为真返回 Ture，否则返回 False。
x.islower() 所有字符都是小写，为真返回 Ture，否则返回 False。
x.isupper() 所有字符都是大写，为真返回 Ture，否则返回 False。
x.istitle() 所有单词都是首字母大写，为真返回 Ture，否则返回 False。
x.isspace() 所有字符都是空白字符，为真返回 Ture，否则返回 False。

课后练习

1. 你知道为什么布尔类型(bool)的 True 和 False 分别用 1 和 0 来代替吗？

answer:计算机只认识二进制，即0和1

3 .我们人类思维是习惯于“四舍五入”法，你有什么办法使得 int() 按照“四舍五入”的方式取整吗？

answer:int(a + 0.5)

>>> a = 6.1
>>> int(a + 0.5)
6
>>> a = 6.5
>>> int(a + 0.5)
7

动动手
1 写一个程序，判断给定年份是否为闰年。（注意：请使用已学过的 BIF 进行灵活运用）
这样定义闰年的:能被4整除但不能被100整除,或者能被400整除都是闰年。

print('----闰年计算器----')
temp = input('请输入年份XXXX，如2014：')
while temp.isdigit()==False :
    temp = input('输入错误，请重新输入:')
year = int(temp)
if year/4==int(year/4) and (year/100!=int(year/100) or year/400==int(year/400)):
    print(year,'年是闰年')
else:
    print(year,'年不是闰年')
print('结束！')

第006讲 python之常用操作符

课堂笔记

加+ 减- 乘* 除/ 取余% 幂** 地板除法//

除法 /

python2 中整数/整数=整数，为地板除法，向下取整，例如：10/8=1
python3 后变为普通除法

地板除法 //

浮点数/浮点数=整数

优先级问题

• 先乘除后加减，括号里的先运算
• 比较操作符优先于逻辑操作符
• 一元操作符/单目操作符：负号-
  二元操作符/双目：and 之类涉及两个数的操作符
• 幂运算优先级比左侧的一元操作符高，比右侧的一元操作符低

>>>-3**2
-9
>>>3**-2
0.1111111111111111

• 幂运算右侧一元操作符>幂运算(**)>正负号(+x -x)>算术操作符(* / // + -)>比较操作符(< <= > >= == !=)>逻辑运算符（not>and>or）
  

课后练习

1.a < b < c 事实上是等于?

answer：(a < b) and (b < c)

4 请用最快速度说出答案：not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9

answer:4

优先级顺序：not > and > or
（not 1 ）or （0 and 1） or （3 and 4） or （5 and 6） or （7 and 8 and 9）
考虑短路逻辑：0 or 0 or 4 or 6 or 9 = 4

注：
1.在纯and语句中，如果每一个表达式都不是假的话，那么返回最后一个，因为需要一直匹配直到最后一个。如果有一个是假，那么返回假
2.在纯or语句中，只要有一个表达式不是假的话，那么就返回这个表达式的值。只有所有都是假，才返回假
3.总而言之，碰到and就往后匹配，碰到or如果or左边的为真，那么就返回or左边的那个值，如果or左边为假，继续匹配or右边的参数。 例如：
(False or 5) 输出5
(5 or False) 输出5
(0 or False) 输出False
(True or 3) 输出True
(2 or True) 输出2
(0 or True) 输出True
(True or False)输出True
(True and 4) 输出4
(1 and True) 输出后者
(False and 1) 输出False
(1 and False) 输出False
(0 and True) 输出0
(not 3) 输出False
(not 0) 输出True

第008讲 了不起的分支和循环2

课堂笔记

python可以有效避免“悬挂else”

强制使用缩进决定if else对应关系避免了“悬挂else”问题

条件表达式（三元操作符）

• 有了这个三元操作符的条件表达式，你可以使用一条语句来完成以下的条件判断和赋值操作：

x,y = 4,5
if x < y:
	small = x
else:
	small = y

例子可以改进为：

small = x if x < y else y

断言（assert）

• assert 这个关键字我们称之为“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常
• 举个例子

>>>assert 3 > 4

• 一般来说我们可以用Ta在程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。

课后练习

2.假设有 x = 1，y = 2，z = 3，请问如何快速将三个变量的值互相交换？

answer: x,y,z = y,z,x

4.你听说过成员资格运算符吗？

answer:'in’用来检查某一个值是否在list中，在则返回True,否则返回False

>>> a = [1,2,3,4]
>>> b = 3
>>> b in a
True

动动手
1.Python 的作者在很长一段时间不肯加入三元操作符就是怕跟C语言一样搞出国际乱码大赛， 蛋疼的复杂度让初学者望而生畏，不过，如果你一旦搞清楚了三元操作符的使用技巧， 或许一些比较复杂的问题反而迎刃而解。

请将以下代码修改为三元操作符实现：
Code:

if x < y and x < z:
   small = x
else:
		if y < z:
     	small = y
		else:
				small = z

small = x if (z<x<y) else (y if y<z else z)

第009讲 了不起的分支和循环3

课堂笔记

for 循环

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

• 语法：
  for 目标 in 表达式：
  循环体

range()

• 语法：range([start,]stop[,step=1])
  • 这个BIF有三个参数，其中使用中括号括起来的两个表示这两个参数是可选的。
  • step =1表示第三个参数默认值为1，start的默认值为0
  • range这个BIF的作用是生成一个从start参数值开始到stop参数值结束的数字序列。

两个重要的语句 break & continue

• break 跳出循环
• continue 终止本轮循环，测试循环条件后执行下一轮循环
• continue 用于while和for 循环

for i in range(10):
    while i%2 !=0:
        print(i)
        continue
    i+=2
    print(i)
#不断输出1的死循环    
"""""""""""""""""""
for i in range(10):
    if i%2 !=0:
        print(i)
        continue
    i+=2
    print(i)
#输出结果 2、1、4、3、6、5、8、7、10、9

课后练习

1.下面的循环会打印多少次”I Love FishC”？

for i in 5:
        print('I Love FishC')

answer:错误，in 是成员资格运算符，不能迭代

TypeError: ‘int’ object is not iterable

6.什么情况下我们要使循环永远为真？

answer:比如用于游戏的实现，游戏只要运行着就要时刻接收用户的输入，用永远为真来确保游戏一直‘’在线‘’。

动动手
0.设计一个验证用户密码程序，用户只有三次机会输入错误，不过如果用户输入的内容中包含"*"则不计算在内。

注：while count： 由于while执行条件为True，当count变为0 =False 循环停止
Code:

print('======================用户密码验证系统====================')
password = '5201314'
count = 3

while count:
    key = input('请您输入密码：')
    if key == password:
        print('祝贺，密码正确！！！')
        print('验证成功！！！')
        break
    elif "*" in key:
        print('抱歉，密码中不能含有*，您还有',count,'次机会',end = '，')
        continue
    else:
        print('密码输入错误！您还有',count - 1,'次机会',end = ',')
    count -= 1

第010讲 列表：一个打了激素的数组1

课堂笔记

数组：同种类型的数据放在一起，通过数组的下标进行索引
python的变量没有数据类型，因此加入了更为强大的列表

创建列表

• 创建一个普通列表

member=['小甲鱼','小布丁','黑夜','迷途','怡静']

• 创建一个混合列表

mix=[1,'小甲鱼',3.14,[1,2,3]]

• 创建一个空列表

empty=[]

向列表添加元素

注：list.XXX 点后面的称之为方法，len()，带括号的称为函数
函数与方法的区别
1.与类和实例无绑定关系的function都属于函数（function）;
2.与类和实例有绑定关系的function都属于方法（method）;
3.函数的调用：函数的调用是直接写 函数名(函数参数1,函数参数2,…) ;
4.方法的调用：方法是通过对象点方法调用的（这里是指对象方法）

list.append(obj) 在列表末尾添加一个元素

obj – 添加到列表末尾的对象。

>>>member.append('福禄娃娃')
>>>member
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静', '福禄娃娃']

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值

用一个列表扩展另一个列表
seq – 元素列表。

>>>member.extend(['竹林小溪','Crazy迷恋'])
>>>member
['小甲鱼', '小布丁', '黑夜', '迷途', '怡静', '福禄娃娃', '竹林小溪', 'Crazy迷恋']

list.insert(index, obj) 将指定对象插入列表的指定位置

index – 对象 obj 需要插入的索引位置。
obj – 要插入列表中的对象。

>>>member.insert(0,'牡丹')
>>>member
['牡丹', '小甲鱼', '小布丁', '黑夜', '迷途', '怡静', '福禄娃娃', '竹林小溪', 'Crazy迷恋']

第011讲 列表：一个打了激素的数组2

课堂笔记

从列表中获取元素

• 根数组一样，我们可以通过元素的索引值（index）从列表获取单个元素，注意，列表索引值是从0开始的。

从列表删除元素

list.remove(obj) 移除列表中某个值的第一个匹配项。

没有匹配项会报错

>>>member.remove('怡静')
>>>member
 ['牡丹', '小甲鱼', '小布丁', '黑夜', '迷途', '福禄娃娃', '竹林小溪', 'Crazy迷恋']

del 语句 删除变量

>>>del member[1]
>>>member
 ['牡丹', '小布丁', '黑夜', '迷途', '福禄娃娃', '竹林小溪', 'Crazy迷恋']

list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

>>>member.pop(1)
'小布丁'
>>>member
['牡丹', '黑夜', '迷途', '福禄娃娃', '竹林小溪', 'Crazy迷恋']

列表分片（slice）

利用索引值，每次我们可以从列表获取一个元素，如果一次性需要获取多个元素，利用列表分片可以实现这个要求。

>>>member[1:3]
['黑夜', '迷途']
>>>member2=member[:]
# 实现变量的拷贝，member2=member直接等于是赋值，相当于一个数贴了两个名字，两个会同样变化，而拷贝不会

课后练习

1. 请问如何将下边这个列表的’小甲鱼’修改为’小鱿鱼’？
   list1 = [1, [1, 2, [‘小甲鱼’]], 3, 5, 8, 13, 18]

list1[1][2][0] = '小鱿鱼'

2. 要对一个列表进行顺序排序，请问使用什么方法？

>>> 列表名.sort()

3. 要对一个列表进行逆序排序，请问使用什么方法？

>>> 列表名.sort()
>>> 列表名.reverse()

或者

>>> 列表名.sort(reverse=True)

4. 列表还有两个内置方法没给大家介绍，不过聪明的你应该可以自己摸索使用的门道吧：copy() 和 clear()

copy() 方法跟使用切片拷贝是一样的：

>>> list2 = list1.copy()
>>> list2
[1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]

clear() 方法用于清空列表的元素，但要注意，清空完后列表仍然还在哦，只是变成一个空列表。

>>> list2.clear()
>>> list2
[]

5. 你有听说过列表推导式或列表解析吗？
   没听过？！没关系，我们现场来学习一下吧，看表达式：

>> [ i*i for i in range(10) ]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

居然分别打印了0到9各个数的平方，然后还放在列表里边了有木有？！

列表推导式（List comprehensions）也叫列表解析，灵感取自函数式编程语言 Haskell。Ta 是一个非常有用和灵活的工具，可以用来动态的创建列表，语法如：
[有关A的表达式 for A in B]
例如

>>> list1 = [x**2 for x in range(10)]
>>> list1
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

相当于

list1 = []
for x in range(10):
	 list1.append(x**2)

问题：请先在 IDLE 中获得下边列表的结果，并按照上方例子把列表推导式还原出来。

>>> list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]

for x in range(10):
    for y in range(10):
        if x % 2 == 0 and  y %2 != 0:
            list2.append((x,y))

第012讲 列表：一个打了激素的数组3

课堂笔记

列表的一些常用操作符

• 比较操作符
• 逻辑操作符
• 连结操作符
• 重复操作符
• 成员关系操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式	结果	描述
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	元素是否存在于列表中（只影响一层）
for x in [1, 2, 3]: print x,	1 2 3	迭代
[123,456]<[456,123]	True	比较（从第一个开始比较，取第一个的结果，若为=则比较下一个）

列表的内置函数&方法

序号	函数	说明
1	cmp(list1, list2)	比较两个列表的元素
2	len(list)	列表元素个数
3	max(list)	返回列表元素最大值
4	min(list)	返回列表元素最小值
5	list(seq)	将元组转换为列表

序号	方法	说明
1	list.append(obj)	在列表末尾添加新的对象
2	list.count(obj)	统计某个元素在列表中出现的次数
3	list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)	将对象插入列表
6	list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)	移除列表中某个值的第一个匹配项
8	list.reverse()	反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False)	对原列表进行排序

课后练习

0.注意，这道题跟上节课的那道题有点儿不同，回答完请上机实验或参考答案。

>>> old = [1, 2, 3, 4, 5]
>>> new = old
>>> old = [6]
>>> print(new)

如果不上机操作，你觉得会打印什么内容？

answer：[1,2,3,4,5]
e.g.:

>>> B = [2, 2, 3, 3, 4, 4, 5, 5]
>>> A = B
>>> A
[2, 2, 3, 3, 4, 4, 5, 5]
>>> C = B[:]
>>> C
[2, 2, 3, 3, 4, 4, 5, 5]
>>> B.sort(reverse = True)
>>> B
[5, 5, 4, 4, 3, 3, 2, 2]
>>> A
[5, 5, 4, 4, 3, 3, 2, 2]
>>> C
[2, 2, 3, 3, 4, 4, 5, 5]

>>> B = [2, 2, 3, 3, 4, 4, 5, 5]
>>> A = B
>>> A
[2, 2, 3, 3, 4, 4, 5, 5]
>>> C = B[:]
>>> C
[2, 2, 3, 3, 4, 4, 5, 5]
>>> B = [6]
>>> B
[6]
>>> A
[2, 2, 3, 3, 4, 4, 5, 5]
>>> C
[2, 2, 3, 3, 4, 4, 5, 5]

第一个A指向了B的内存地址;第二个B重新开辟了一个内存地址

第013讲 元组（tuple）：戴上了枷锁的列表

课堂笔记

• 由于和列表是近亲关系，所以元组和列表在实际使用上是非常相似的。不同之处在于元组的元素不能修改。

创建和访问一个元组

• 创建列表一般使用[ ]，元组一般使用（ ）
• 创建空元组
  tup1 = ()
• 元组中只包含一个元素时，需要在元素后面添加逗号，tuple1=（1）是整型，tuple2=2，3，4 是元组
  tup1 = (50,) 等价于 tup1=50,
• 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。访问元组元素方法与列表相同,例：tuple[5:]；元组拷贝同样可以使用 tuple2=tuple1[:]

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, ‘小甲鱼’))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(8,) * 4	(8，8，8，8)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，
L = (‘spam’, ‘Spam’, ‘SPAM!’)

Python 表达式	结果	描述
L[2]	‘SPAM!’	读取第三个元素
L[-2]	‘Spam’	反向读取，读取倒数第二个元素
L[1:]	(‘Spam’, ‘SPAM!’)	截取元素
L[x:y:z]		切片索引,x是左端,y是右端,z是步长,在[x,y)区间从左到右每隔z取值,默认z为1可以省略z参数.

步长的负号就是反向,从右到左取值.

修改元组

类似于字符串，元组中的元素值是不允许修改的，但我们可以对元组进行截取后连接组合。

>>>temp=('小甲鱼','黑夜','迷途','小布丁')
>>>temp=temp[:2]+('怡静',)+temp[2:]
>>>temp
('小甲鱼', '黑夜', '怡静', '迷途', '小布丁')

截取后生成了新的元组，并把temp的标签给了新元组，原来的元组还在存储位置，失去标签后不久会被回收器清除

删除元组

元组中的元素值是不允许删除的，要删除单个元素的话可以使用截取的方式，但我们可以使用del语句来删除整个元组

del temp

第014讲 字符串:各种奇葩的内置方法

课堂笔记

• 字符串类似于元组，只能通过裁剪拼接实现‘修改’

python的字符串内建函数

方法	描述
string.capitalize()	把字符串的第一个字符改为大写
string.casefold()	把整个字符串的所有字符改为小写
string.center(width)	将字符串居中，并使用空格填充至长度 width 的新字符串
string.count(sub[, start[, end]])	返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
string.encode(encoding=‘utf-8’, errors=‘strict’)	以 encoding 指定的编码格式对字符串进行编码。
string.endswith(sub[, start[, end]])	检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
string.expandtabs([tabsize=8])	把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
string.find(sub[, start[, end]])	检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。
string.index(sub[, start[, end]])	跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。
string.isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。