《零基础入门学习python》学习过程（四）

学习时间：2017/09/19

第14课：元组

知识点汇总：

1. 元组和列表最本质的区别就是元组是封闭的列表，它一旦定义就不可修改，不可插入或删除任意一个元素等操作。
2. 创建和访问一个元组

>>> tuple2=()  #创建一个空元组
>>> type(tuple2)
<class 'tuple'>
>>> tuple3=(1,)    #或‘tuple3=1,’创建一个只有一个元素的元组（注意有逗号）
>>> type(tuple3)
<class 'tuple'>

>>> tuple1=(1,2,3,4,5,6,7,8)  #访问一个元组
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1[1]
2
>>> tuple1[5:]
(6, 7, 8)
>>> tuple1[:5]
(1, 2, 3, 4, 5)

逗号对元组的重要性：

>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)

3.更新和删除一个元组

>>> temp=('小甲鱼','黑夜','迷途','小布丁')    #元组的更新，创建新的元组覆盖旧的
>>> temp=temp[:2]+('怡静',)+temp[2:]  
#在拼接只有一个元素的元组时，逗号和小括号都不能少
>>> temp
('小甲鱼', '黑夜', '怡静', '迷途', '小布丁')

>>> del temp  #删除元组

4.元组的相关操作符：与列表相同

第15、16节课：字符串

知识点汇总：

1.常见字符串操作：

>>> str1='i love you'
>>> str1.capitalize()  
#把字符串的第一个字符改成大写（创建了新的字符串，旧字符串未改变）
'I love you'


>>> str1.casefold() 
#把整个字符串的所有字符改成小写  
'i love you'


>>> str1.center(20)   
#将字符串居中，并用空格填充至长度width 
'     i love you     '


>>> str1.count('o',1,8)  
#返回sub在字符串中出现的次数，起始位置和终止位置可选
#起始位置计算在内，终止位置不算
1 


>>> str1.endswith('yo',1,10)
#检查字符串是否以sub子字符串结束，如果是返回True，否则False，起始和结束位置可选
False


>>> str2='i\tlove\tyou'
>>> str2.expandtabs(3)
#把字符串中的tab符号(\t)转换为空格，如不指定参数，默认的空格数是tabsize=8
'i  love  you'


>>> str2.find('gao')
#检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1，start和end参数可选
-1
>>> str2.find('o',0,6)
3


>>> str2.index('gao')
#和find方法一样，区别在于如果sub不在字符串中则产生异常
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    str2.index('gao')
ValueError: substring not found

更多字符串方法及注释看这里：字符串的方法及注释

2.格式化

使用位置参数：

>>> "{0} love {1}.{2}".format("i","fishc","com")
'i love fishc.com'

使用关键字参数：

>>> "{a} love {b}.{c}".format(a="i",b="fishc",c="com")
'i love fishc.com'

综合位置参数和关键字参数（位置参数必须在前，否则报错）：

>>> "{0} love {b}.{c}".format("i",b="fishc",c="com")
'i love fishc.com'

数值格式化举例：

>>> "{0:.1f}{1}".format(27.678,"GB")
#`:`表示格式化开始，`.1`表示保留一位小数，`f`表示浮点数
'27.7GB'


>>> '%f'%27
#%为格式化符号，格式化为浮点数，默认保留六位小数
'27.000000'


>>> '%e'%27.658
#格式化为科学计数法
'2.765800e+01'

格式化字符及其ASCII码：

>>> '%c' %97
#返回ASCII码为97的字符
'a'
>>> '%c %c %c'%(97,98,99)
'a b c'

格式化字符串：

>>> '%s %s %s'%('i','love','you')
'i love you'

格式化整数：

>>> '%d + %d = %d'%(4,5,4+5)
'4 + 5 = 9'

进制转换：十进制整数格式化为无符号八进制数%o ，格式化为无符号十进制数（小写）%x，格式化为无符号十进制数（大写）%X

>>> '%o'%10
'12'
>>> '%x'%10
'a'
>>> '%X'%10
'A'

格式化操作符m.n:m为显示的最小总宽度，n为小数点后的位数

>>> '%5.1f'%27.658
' 27.7'
>>> '%8.1e'%27.658
' 2.8e+01'

格式化操作符-：用于左对齐

>>> '%10d'% 5
'         5'
>>> '%-10d'%5
'5         '

格式化操作符+：在正数前面显示加号

>>> '%+d'%5
'+5'

格式化操作符#：在八进制数前面显示'0o'，在十六进制数前面显示'0x'或'0X'

>>> '%#o'%10
'0o12'
>>> '%#x'%1024
'0x400'

格式化操作符0：显示的数字前面填充0取代空格

>>> '%010d'%5
'0000000005'
>>> '%-010d'%5
'5 

更多字符串格式化符号含义及转义字符含义看这里：字符串格式化符号含义及转义字符含义

重要课后题汇总：

1.请问以下这行代码会打印什么内容？

>>> "{{1}}".format("不打印", "打印")
'{1}'

因为外面的花括号{}把里面的花括号{}转义为字符，不能起到位置参数的作用了。

2.编写一个进制转换程序（提示，十进制转换为二进制可以用bin()这个内置函数）

while True:
    num=input("请输入一个整数（输入Q结束程序）：")
    if num !='Q':
        num=int(num)
        print('十进制->二进制：%d -> ' %num,bin(num))
        print('十进制->八进制：%d -> 0o%o' %(num,num))
        print('十进制->十六进制：%d -> 0x%x ' %(num,num))
    else:
        break

第17节课：序列

知识点汇总：

1.列表、元组和字符串的共同点：
- 都可以通过索引得到每一个元素
- 默认索引值总是从0开始
- 可以通过分片的方法得到一个范围内的元素的集合
- 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
统称为序列。
2.序列常见的内置方法
list([iterable])：把一个可迭代对象转换为列表
tuple([iterable])：把一个可迭代对象转换为元组

>>> a='i love you'
>>> a=list(a)
>>> a
['i', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u']

>>> b=(1,1,2,3,5,8,13,21,34)
>>> b=list(b)
>>> b
[1, 1, 2, 3, 5, 8, 13, 21, 34]

str(obj)：把obj对象转换为字符串
max()：返回序列或者参数集合中的最大值（保证数据类型都相同）

>>> max(1,2,3,7,5)
7

>>> a='i love you'
>>> max(a)
'y'

min()：返回序列或者参数集合中的最小值（保证数据类型都相同）

>>> c=[2,3,4,-89,5]
>>> min(c)
-89

sum(iterable[,start=0])：返回序列iterable和可选参数start的总和

>>> numbers=(1.2,2.3,6.5)
>>> sum(numbers)
10.0
>>> sum(numbers,7)
17.0

>>> char='123456'
>>> sum(char)   #sum有个缺陷，就是如果参数中有字符串类型就会报错
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    sum(char)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

sorted()：返回一个正排序的列表

>>> chars='jduahfb'
>>> sorted(chars)
['a', 'b', 'd', 'f', 'h', 'j', 'u']

>>> numbers=(1.2,2.3,6.5)
>>> sorted(numbers)
[1.2, 2.3, 6.5]
>>> 

reversed()：返回一个对象，可用list()再返回为列表，该列表是原序列的反序。

>>> number=(1,2,3,4,-5)
>>>> reversed(number)
<reversed object at 0x000002ED8D2D09E8>
>>> list(reversed(number))
[-5, 4, 3, 2, 1]

enumerate()：返回一个对象，再由list()返回一个列表，该列表的每个元素是由原序列中每个元素的index值和item值组成的元组。

>>> number=(1,2,3,4,-5)
>>> enumerate(number)
<enumerate object at 0x000002ED8D23B8B8>
>>> list(enumerate(number))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, -5)]

zip()：返回一个对象，再由list()返回一个列表，该列表的各个元素为zip参数中相同index值的元素组成的元组。

>>> a=[1,2,3,4,5,6,7]
>>> b=[5,6,7,8,9]
>>> zip(a,b)
<zip object at 0x000002ED8D2DCD08>
>>> list(zip(a,b))
[(1, 5), (2, 6), (3, 7), (4, 8), (5, 9)]

重要课后题汇总：

1.什么是迭代？
所谓迭代，就是重复反馈过程的活动，其目的通常是为了接近并达到所需的目标或结果。每一次对过程的重复被称为依次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。

2.一个迭代的实例

name=input("请输入待查找的用户名：")

score=[('迷途',85),('黑夜',80),('小布丁',65),('福禄',95),('怡静',90)]
isfind=False

for each in score:
    if name in each:
        print(name+'的得分为：',each[1])
        isfind=True
        break

if isfind==False:
    print("查找的数据不存在！")

3.猜想一下min()这个BIF的实现过程

def min(x):
    least=x[0]

    for each in x:
        if each<least:
            least=each

    return least

4.我们说 sum() 这个BIF有个缺陷，就是如果参数里有字符串类型的话就会报错，请写出一个新的实现过程，自动“无视”参数里的字符串并返回正确的计算结果。

def sum(x):
    result=0

    for each in x:
        if(type(each)==int) or (type(each)==float):
            result +=each
        else:
            continue

    return result