Python-100-days学习笔记（一）

学习资源：link

对应章节：01-09

在下NWPU在读，借此机会系统的学习一下python。

HC. 19.08.16

python之禅

import this

编译结果：

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!

变量及相关运算

数据类型

整型：Python中可以处理任意大小的整数（Python 2.x中有int和long两种类型的整数，但这种区分对Python来说意义不大，因此在Python 3.x中整数只有int这一种了），而且支持二进制（如0b100，换算成十进制是4）、八进制（如0o100，换算成十进制是64）、十进制（100）和十六进制（0x100，换算成十进制是256）的表示法。
浮点型：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，浮点数除了数学写法（如123.456）之外还支持科学计数法（如1.23456e2）。
字符串型：字符串是以单引号或双引号括起来的任意文本，比如'hello'和"hello",字符串还有原始字符串表示法、字节字符串表示法、Unicode字符串表示法，而且可以书写成多行的形式（用三个单引号或三个双引号开头，三个单引号或三个双引号结尾）。
布尔型：布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来（例如3 < 5会产生布尔值True，而2 == 1会产生布尔值False）。
复数型：形如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j。
在对变量类型进行转换时可以使用Python的内置函数（准确的说下面列出的并不是真正意义上的函数，而是后面我们要讲到的创建对象的构造方法）。
int()：将一个数值或字符串转换成整数，可以指定进制。
float()：将一个字符串转换成浮点数。
str()：将指定的对象转换成字符串形式，可以指定编码。
chr()：将整数转换成该编码对应的字符串（一个字符）。
ord()：将字符串（一个字符）转换成对应的编码（整数）。

运算符

运算符	描述
`[]` `[:]`	下标，切片
`**`	指数
`~` `+` `-`	按位取反, 正负号
`*` `/` `%` `//`	乘，除，模，整除
`+` `-`	加，减
`>>` `<<`	右移，左移
`&`	按位与
`^` `\\|`	按位异或，按位或
`<=` `<` `>` `>=`	小于等于，小于，大于，大于等于
`==` `!=`	等于，不等于
`is` `is not`	身份运算符
`in` `not in`	成员运算符
`not` `or` `and`	逻辑运算符
`=` `+=` `-=` `=` `/=` `%=` `//=` `*=` `&=` `\|=` `^=` `>>=` `<<=`	（复合）赋值运算符

分支及循环结构

if xxxx: # 注意不要漏掉冒号：xxxx
elif xxxx: # 注意不要漏掉冒号：xxxx
else: # 注意不要漏掉冒号：xxxx

for x in range(101):sum += x
# range： range(n) : 返回 [0,1,2,...,n-1]
# range(n,m) : 返回 [n,n+1,n+2,...,m-1]
# range(n,m,o) : 返回 [n,n+o....]

while xxxx:xxxx

函数

def function_name(args): # *args代表输入参数数量是可变的xxxxreturn xxxx

同一模块下的同名函数，后面的定义会覆盖之前的。

python中可以将同名函数定义到不同的模块里，分模块调用，即可完成区分。（当然，为什么要定义同名函数。。。。）

name=main

例子1：

module1.py：

def add(a,b):return a+ba = 1
b = 2
print(add(a,b))

module2.py：

import module1
print(module1.add(3,4))

编译module1，输出：

编译module2，输出：

3
7

在import module1的同时，module1中的代码被执行，而我们其实只是需要module1中的add方法。

例子2：

module1.py：

def add(a,b):return a+bif __name__ == '__main__':a = 1b = 2 print(add(a,b))

module2.py：

import module1
print(module1.add(3,4))

编译module1，输出：

编译module2，输出：

当添加了if __name__ == '__main__':语句后，仅仅当直接执行该python文件时，脚本代码才会被执行。

name__是Python中一个隐含的变量它代表了模块的名字
只有被Python解释器直接执行的模块的名字才是__main

常用数据结构

列表

def main():list = [] # 空列表list1 = [1, 3, 5, 7, 100]print(list1) list2 = ['hello'] * 5print(list2)# 计算列表长度(元素个数)print(len(list1))# 下标(索引)运算print(list1[0])print(list1[4])# print(list1[5])  # IndexError: list index out of rangeprint(list1[-1])print(list1[-3])list1[2] = 300print(list1)# 添加元素list1.append(200) # 常用list1.insert(1, 400)list1 += [1000, 2000]print(list1)print(len(list1))# 删除元素list1.remove(3)if 1234 in list1:list1.remove(1234)del list1[0]print(list1)# 清空列表元素list1.clear()print(list1)if __name__ == '__main__':main()

列表切片

def main():fruits = ['grape', 'apple', 'strawberry', 'waxberry']fruits += ['pitaya', 'pear', 'mango']# 循环遍历列表元素for fruit in fruits:print(fruit.title(), end=' ')print()# 列表切片fruits2 = fruits[1:4]print(fruits2)# fruit3 = fruits  # 没有复制列表只创建了新的引用# 可以通过完整切片操作来复制列表fruits3 = fruits[:]print(fruits3)fruits4 = fruits[-3:-1]print(fruits4)# 可以通过反向切片操作来获得倒转后的列表的拷贝fruits5 = fruits[::-1]print(fruits5)if __name__ == '__main__':main()

列表排序

def main():list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']list2 = sorted(list1)# sorted函数返回列表排序后的拷贝不会修改传入的列表# 函数的设计就应该像sorted函数一样尽可能不产生副作用list3 = sorted(list1, reverse=True)# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序list4 = sorted(list1, key=len)print(list1)print(list2)print(list3)print(list4)# 给列表对象发出排序消息直接在列表对象上进行排序list1.sort(reverse=True)print(list1)if __name__ == '__main__':main()

生成式语法创建列表：

import sysdef main():f = [x for x in range(1, 10)]print(f)f = [x + y for x in 'ABCDE' for y in '1234567']print(f)# 用列表的生成表达式语法创建列表容器# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间f = [x ** 2 for x in range(1, 1000)]print(sys.getsizeof(f))  # 查看对象占用内存的字节数print(f)# 请注意下面的代码创建的不是一个列表而是一个生成器对象# 通过生成器可以获取到数据但它不占用额外的空间存储数据# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)f = (x ** 2 for x in range(1, 1000))print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间print(f)for val in f:print(val)if __name__ == '__main__':main()

使用列表相当于提前把数据算好并保存起来，这样调用花的时间短但是占用空间多，生成器占用空间小但是每次调用都要计算，因此花费时间多。

元组

def main():# 定义元组t = ('骆昊', 38, True, '四川成都')print(t)# 获取元组中的元素print(t[0])print(t[3])# 遍历元组中的值for member in t:print(member)# 重新给元组赋值# t[0] = '王大锤'  # TypeError# 变量t重新引用了新的元组原来的元组将被垃圾回收t = ('王大锤', 20, True, '云南昆明')print(t)# 将元组转换成列表person = list(t)print(person)# 列表是可以修改它的元素的person[0] = '李小龙'person[1] = 25print(person)# 将列表转换成元组fruits_list = ['apple', 'banana', 'orange']fruits_tuple = tuple(fruits_list)print(fruits_tuple)if __name__ == '__main__':main()

元组不能直接修改，但是可以先转为列表在转回去。

集合

def main():set1 = {1, 2, 3, 3, 3, 2}print(set1) # 这里输出 1 2 3，重复的2和3不会多次输出 print('Length =', len(set1))set2 = set(range(1, 10))print(set2)set1.add(4)set1.add(5)set2.update([11, 12])print(set1)print(set2)set2.discard(5)# remove的元素如果不存在会引发KeyErrorif 4 in set2:set2.remove(4)print(set2)# 遍历集合容器for elem in set2:print(elem ** 2, end=' ')print()# 将元组转换成集合set3 = set((1, 2, 3, 3, 2, 1))print(set3.pop())print(set3)# 集合的交集、并集、差集、对称差运算print(set1 & set2)# print(set1.intersection(set2))print(set1 | set2)# print(set1.union(set2))print(set1 - set2)# print(set1.difference(set2))print(set1 ^ set2)# print(set1.symmetric_difference(set2))# 判断子集和超集print(set2 <= set1)# print(set2.issubset(set1))print(set3 <= set1)# print(set3.issubset(set1))print(set1 >= set2)# print(set1.issuperset(set2))print(set1 >= set3)# print(set1.issuperset(set3))if __name__ == '__main__':main()

集合元素不会重复。所谓对称差其实就是 1里面2没有的+2里面1没有的。

字典

def main():scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}# 通过键可以获取字典中对应的值print(scores['骆昊'])print(scores['狄仁杰'])# 对字典进行遍历(遍历的其实是键再通过键取对应的值)for elem in scores:print('%s\t--->\t%d' % (elem, scores[elem]))# 更新字典中的元素scores['白元芳'] = 65scores['诸葛王朗'] = 71scores.update(冷面=67, 方启鹤=85)print(scores)if '武则天' in scores:print(scores['武则天'])print(scores.get('武则天'))# get方法也是通过键获取对应的值但是可以设置默认值print(scores.get('武则天', 60))# 删除字典中的元素print(scores.popitem())print(scores.popitem())print(scores.pop('骆昊', 100))# 清空字典scores.clear()print(scores)if __name__ == '__main__':main()

面向对象编程

面向对象有三大支柱：封装、继承和多态。个人理解：

封装：对于用户来说，只需要看见接口，不需要看见实现细节。你只需要学习怎么操作手机，并不需要知道手机里面复杂的功能是怎么实现的。
继承：由一个基础的类（父类）可以衍生出许多子类，子类拥有着和父类相似的特征。例如父类“人‘’有性别，年龄，体重。由“人”衍生出的子类“学生”除了拥有性别年龄外还拥有自己的特征“成绩”。

多态：由同一父类衍生出的许多子类在某些特征上可能有不同之处。例如由“人”所衍生出的子类“学生”和“营销员”。评价学生成绩的标准是分数，而评价营业员成绩的标准是营业额，因此在写“查询该对象的成绩”方法时，学生和营销员的方法存在不同。

创建类

class Student(object):# __init__是一个特殊方法用于在创建对象时进行初始化操作# 通过这个方法我们可以为学生对象绑定name和age两个属性def __init__(self, name, age):self.name = nameself.age = agedef study(self, course_name):print('%s正在学习%s.' % (self.name, course_name))# PEP 8要求标识符的名字用全小写多个单词用下划线连接# 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)def watch_movie(self):if self.age < 18:print('%s只能观看《熊出没》.' % self.name)else:print('%s正在观看岛国爱情大电影.' % self.name)

使用类

def main():# 创建学生对象并指定姓名和年龄stu1 = Student('骆昊', 38)# 给对象发study消息stu1.study('Python程序设计')# 给对象发watch_av消息stu1.watch_movie()stu2 = Student('王大锤', 15)stu2.study('思想品德')stu2.watch_movie()if __name__ == '__main__':main()

继承类

class Person(object):"""人"""def __init__(self, name, age):self._name = nameself._age = age@propertydef name(self):return self._name@propertydef age(self):return self._age@age.setterdef age(self, age):self._age = agedef play(self):print('%s正在愉快的玩耍.' % self._name)def watch_av(self):if self._age >= 18:print('%s正在观看爱情动作片.' % self._name)else:print('%s只能观看《熊出没》.' % self._name)class Student(Person):"""学生"""def __init__(self, name, age, grade):super().__init__(name, age)self._grade = grade@propertydef grade(self):return self._grade@grade.setterdef grade(self, grade):self._grade = gradedef study(self, course):print('%s的%s正在学习%s.' % (self._grade, self._name, course))class Teacher(Person):"""老师"""def __init__(self, name, age, title):super().__init__(name, age)self._title = title@propertydef title(self):return self._title@title.setterdef title(self, title):self._title = titledef teach(self, course):print('%s%s正在讲%s.' % (self._name, self._title, course))def main():stu = Student('王大锤', 15, '初三')stu.study('数学')stu.watch_av()t = Teacher('骆昊', 38, '砖家')t.teach('Python程序设计')t.watch_av()if __name__ == '__main__':main()

多态类

from abc import ABCMeta, abstractmethodclass Pet(object, metaclass=ABCMeta):"""宠物"""def __init__(self, nickname):self._nickname = nickname@abstractmethoddef make_voice(self):"""发出声音"""pass# 狗和猫的“make_voice”方法不同class Dog(Pet):"""狗"""def make_voice(self):print('%s: 汪汪汪...' % self._nickname)class Cat(Pet):"""猫"""def make_voice(self):print('%s: 喵...喵...' % self._nickname)def main():pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]for pet in pets:pet.make_voice()if __name__ == '__main__':main()