Python学习笔记（进阶）

目录

字典

生成对象面向对象编程(oop)是一种封装代码的方法

扩展类

模块

---

字典

1.创建方法，键：值，每个键/值之间用逗号分隔，整个字典用{}括起来。添加新键通过方括号[]加入。

>>> states={"vir":"dfs","mar":"ann","new":"albay"}#创建字典
>>> print(states)
{'vir': 'dfs', 'mar': 'ann', 'new': 'albay'}
>>> states['ore']='sda'#添加键/值
>>> print(states)
{'vir': 'dfs', 'mar': 'ann', 'new': 'albay', 'ore': 'sda'}
>>> type(states)
<class 'dict'>

字典和使用列表不同，如果某个键不存在不会得到错误，如果你用一个已经存在的键来存储新值，旧值将会被删除，并且把新值作为该键的配对来保存。键是唯一的，但值不是唯一的

>>> states['ore']='sdfdfsdf'
>>> print(states)
{'vir': 'dfs', 'mar': 'ann', 'new': 'albay', 'ore': 'sdfdfsdf'}

2.删除一个键，使用pop()函数。字典名.pop(键)
pop()函数从字典中删除一个键并返回这个键所对应的值。如果没有键跟pop匹配将抛出一个错误。

>>> states.pop('ore')
'sdfdfsdf'
>>> states
{'vir': 'dfs', 'mar': 'ann', 'new': 'albay'}

3.列表不能用作键，因为没有办法把列表识别为唯一的，但是可以用作值，键跟值的数据类型可以自由搭配。

>>> holida={'oc':['dfd','sdf']}
>>> holida
{'oc': ['dfd', 'sdf']}
>>> hol={['df']:'dfd'}
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    hol={['df']:'dfd'}
TypeError: unhashable type: 'list'

4.从字典中取出值，变量后紧跟着方括号括住的键。没有与键对应的值，程序会报错并停止运行。
如果不知道字典中有什么样的键，Python中提供了一个函数来查看字典中是否有这么一个键。has_key()函数
字典名.has_key(键)，如果有该键，返回True，没有，返回False。
也可以使用关键字in来查看键是否在字典中  键 in 字典名
不过现在Python 3 版本里面不能使用has_key()函数了，只能使用in来判断键是否在字典中

>>> states['vir']
'dfs'
>>> states['ddd']
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    states['ddd']
KeyError: 'ddd'
>>> states.has_key('mar')
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    states.has_key('mar')
AttributeError: 'dict' object has no attribute 'has_key'
>>> 'new' in states
True
>>> 'ndf' in states
False

5.values()返回所有值的列表，变量.values()
   keys()返回所有键的列表

6.字典的比较跟顺序无关，只要两个字典里面的内容完全一致，顺序不一样也是返回True，列表的话，则顺序必须一样并且完全相等才会True，所以如果需要让项按照特定的顺序存储，应该使用列表。

7.使用items()函数可以获取字典里面的键、值

>>> states={'sdf':'sfs','sff':'sfsd',233:234,23.23:"sdf"}
>>> for key,value in states.items():
	print("{}  {}".format(key,value))

	
sdf  sfs
sff  sfsd
233  234
23.23  sdf

生成对象面向对象编程(oop)是一种封装代码的方法

术语
属性：一个对象拥有的值
方法：对象所附带的函数，只能与其对象一直使用
实例：创建一个新的对象，就称之为一个实例。从技术上讲，当创建一个新的变量并且为它设置值时，我们在创建该数据类型的一个实例。当你改变一个实例中的值，只会针对该实例做出更改，而不是针对这个数据类型的所有对象做出更改。
类：对象的蓝图。类为对象定义了方法和属性，并且设置了所有的默认值。
子类：当基于一个已有的类生成一个新类时，我们在对其子类化。子类得到了父类的所有属性、默认值和函数。

生成类

1.定义类，包括这个类的所有方法和属性
2.创建一个实例，必须调用该类，在类名称后加一对圆括号就可以了
3.看属性中的内容，在变量名称的后边，添加属性的名称就可以了
4.修改属性的值，跟 修改其他变量的值是一样的。

#定义类
>>> class MyClass(object):
	a=5
	b=2

	
>>> new_item=MyClass#创建实例
>>> new_item.a#查看属性内容
5
>>> new_item.a=13#修改属性值
>>> new_item.a
13

5.为类增加方法
为类定义一个方法与为程序定义一个方法非常类似，但是类中定义的方法至少会有一个参数，即self（对象中包含的所有内容）
调用类的函数时，要在函数名字前添加变量名称，self是告诉Python，我们想要使用当前对象中所存储的属性和方法，而不是一些新的变量。

>>> class School(object):
	name=''
	address=''
	type='grade school'
	def print_school(self):
		print(self.name)
		print(self.address)
		print("Type:"+self.type)

		
>>> school1=School()
>>> school1.print_school()


Type:grade school
>>> school1.name='Wyland'
>>> school1.address='100\nva'
>>> school1.type='university'
>>> school1.print_school()
Wyland
100
va
Type:university

6.__init__()函数
第一次创建一个新的类的实例时，Python会检查是否定义了一个__init__()函数，如果已经定义了，就会运行这个函数。
必须使用self来定义属性，可以为这个函数传递值，没有定义则什么都不会发生。

#不带参数
>>> class student(object):
	def __init__(self):
		self.name='none'
		self.garde='A'

		
>>> student1=student()
>>> student1.name
'none'
#带参数
>>> class students(object):
	def __init__(self,name='none',garde='A'):
		self.name=name
		self.garde=garde

		
>>> students1=students()
>>> students2=students(name='byron',garde='B')
>>> students1.name
'none'
>>> students2.name
'byron'

如果用户提供了默认值，__init__()函数会使用它们，如果什么都没有提供，__init__()函数会从用户那里得到它所需要的信息，甚至会判断值是否是有效的。

7.创建一个类的新实例，这样调用 ，my_var=NewClass()

 

扩展类

比较两个值是否相等

>>> class Test(object):
	def __init__(self):
		self.num=5

		
>>> a=Test()
>>> b=Test()
>>> a==b
False

我们知道a和b应该是相等的，因为这里只有一个属性，而且它们应该是相同的。但是Python不知道如何去比较，这时就需要编写一个新的函数：__eq__()
1.__eq__()函数，接受两个参数，self和另一个对象，当测试相等性时，self是==操作符前边的项，操作符后边的项作为参数传递进来，现在我们为Test类添加__eq__()函数

>>> class Test(object):
	def __init__(self,num):
		self.num=num
	def __eq__(self,other):
		if(self.num==other.num):
			return True
		else:
			return False

		
>>> a=Test(5)
>>> b=Test(6)
>>> c=Test(5)
>>> a==b
False
>>> a==c
True

现在，Python知道如何判断相等性了：它检查数字属性是否相等，但是这不意味着Python知道如何判断不等性，要想让Python知道如何判断不等性需要编写另一个函数__ne__()函数
2.__ne__()函数，如果对象不相等，返回True
3.__gt__()函数，大于性
   __lt__()函数，小于性
   __gte__()函数，大于等于性
   __lte__()函数，小于等于性。 这些函数和__eq__()函数的工作方式类似。

4.操作打印，如果试图直接打印一个Test对象，会得到一些奇怪的输出，这时我们需要编写一个__str__()函数，只接受一个参数（self），并且返回一个字符串。

#这是没有加__str__()函数的时候
>>> print(a)
<__main__.Test object at 0x0374D1F0>
#加了以后
>>> class Test(object):
	def __init__(self,num,other):
		self.num=num
		self.other=other
	def __str__(self):
		return self.other

	
>>> pa=Test(7,"sfds")
>>> print(pa)
sfds

当我们打印pa时，Python会判断Test类应该打印输出什么，因为我们覆盖了__str__()函数。
要记住：在__str__()函数的末尾一定要返回一些内容，如果没有返回，Python会混淆，从而抛出一个错误。

5.类的继承
在我们有了一个基类（Inven）时，我们要来创建一个继承自它的新类（Book）时，把基类的名称放在通常放置对象的圆括号中，从而告诉Python，想要继承自该类。声明Book时，用“class Book(Inven):”
super()是Python中一个特殊的函数，告诉Python调用父类中的一个函数。
当我们在子类中重新编写了父类中编写过的方法时，这叫做覆盖，使用继承时，覆盖极其常见。
覆盖只会改变在子类中的使用方法，而不会改变父类
"http://docs.python.org/3/reference/datamodel"中可以找到数据类型的一个详尽列表
如果想不传递self来生成一个方法，只要在方法定义前加上“@staticmethod”，Python就知道不需要给这个函数传递self了。

 

模块

Python有一个充满项目的、丰富的类库，类库中的项目叫包，包中是模块，模块就是包含一些函数以及为了给程序添加特定功能而编写的一些类的文件，一个包可能包含多个模块，但是，通常一个包中的模块都有一个共同主题。简单说，包就是一个目录，模块就是这个目录中的一个文件。

1.包
想要使用Python中的类库，不需要安装任何东西，只要使用import命令来告诉Python。
使用import命令的两种方法：导入整个模块或选择想要导入的模块
导入一些模块可能会节省很多输入工作，因为不必在类或函数前放置模块的名称
目前你需要了解的一些包

random	生成随机数的一组模块
os	专用于与操作系统交互的一个包
json	用来生成和读取JavaScript Object NOtation文件的一个包，它提供了很多方法来存储和共享数据
sqlite3	用来创建、编辑和读取SQLite数据库的一个包
datetime	用来操作日期和时间的一个包
getpass	用来获取用户敏感信息的一个包
this	一个复活节彩蛋，当你输入import this时，将输出Python的信息
pprint	用来以更易于阅读的格式打印数据的一个包

想了解关于包的更多信息，请参见“http://docs.python.org/3/library/"

2.random模块
想要使用random，可以在Shell或文件的开头输入import random。也可以使用from module import class/function语法，选择只导入所需要的函数或类
2.1 只使用randint()函数

>>> from random import randint
>>> for i in range(10):
	print(randint(1,10))

	
5
8
7
6
3
7
9
4
2
7

randint()函数给出了给定的两个数字之间的一个随机值，数字范围包括那两个给定的数字。
想要使用random模块的更多函数，可以使用import random，将从该模块导入所有的函数，但我们调用randit()时，需要把random放在这个调用的开头
2.2 random()函数，返回一个0到1之间的随机的浮点数，不包括0和1。random()不接收任何参数，所以不能得到特定区间的浮点数。
2.3 uniform()函数，返回一个特定区间的浮点数，接受两个参数，与random()一样，uniform()函数也不包括给定的两个参数。
2.3 choice()函数，接受一个列表或元组，从中随机地返回一个项。

3.获取模块的更多信息，将模块导入Shell中，然后对其使用内建函数help()，但到更多关于它的信息。
eg.你导入random，然后输入help(random)，将会显示random模块的文档。

4.datetime模块
4.1  time，这个模块用来创建和操作时间对象。
       time()不需要任何参数，但是它可以接受4个整数，分别赋给小时、分钟、秒和微秒。
一旦得到一个time实例，可以获取准确的小时，分钟和秒

>>> from datetime import time
>>> lunch=time(11,23,34,23)
>>> print(lunch)
11:23:34.000023
>>> lunch.hour
11
>>> lunch.minute
23
>>> lunch.second
34

如果不想使用time的默认格式，可以通过格式化输出配合获取的小时，分钟来操作。
比较time对象，如果一个时间发生在 一天晚些时候，我们认为那个时间”大于“同一天早些时候的时间。

>>> import datetime
>>> breakfast=datetime.time(7,30)
>>> lunch=datetime.time(11,20)
>>> ele=datetime.time(11,20)
>>> breakfast>lunch
False
>>> breakfast<ele
True
>>> ele==lunch
True

4.2  datetime,用于保存日期在和时间。
datetime(year,month,day[,hour[,minute[,second[,microsecond[,tzinfo]]]]])
用一个datetime实例减去一个datetime实例，将会得到一个timedelta的对象，它包含了一些天数，如果有必要还会有一些秒数。

>>> import datetime
>>> hm=datetime.datetime(2009,9,1)
>>> jt=datetime.datetime(2001,4,14)
>>> hm-jt
datetime.timedelta(days=3062)

>>> week=datetime.timedelta(7)#参数也可以是days=7
>>> n=datetime.datetime.now()#获取现在的日期时间
>>> n+week
datetime.datetime(2019, 5, 11, 14, 34, 7, 604616)

在“pypi.python.org”中，你几乎可以找到当前为Python开发的所有第3方模块。
在“http://wiki.python.org/moin/UsefulModules”中， 可以找到模块的一个不完全的列表。