python知识简单总结

基础

• 字符串是不可改变的
• 格式化方法：format()
  将一下内容为文件 str_format.py

age	=	20 name	=	'Swaroop'   
print('{0} was {1} years old when he wrote this book'.format(name,	age)) 
print('Why is {0} playing with that python?'.format(name))

输出：

$ python str_format.py
Swaroop was 20 years old when he wrote this book 
Why is Swaroop playing with that python?

计算命令

• lambda：Lambda表达式
• if-else：条件表达式
• or: 布尔“或”
• and：布尔“与”
• not x：布尔“非”
• in,not in,is, is not,<,<=,>, >=, !=, ==：比较，包括成员资格测试 （Membership Tests）和身份测试（Identity Tests）。
• |：按位或
• ^ ：按位异或
• &：按位与
• <<,>>：移动
• +，-：加或减
• *，/，//，%：乘，除，整除，取余
• +x，-x，~x：正、负、按位取整
• **：求幂
• x[index],x[index:index],x(arguments…),x.attribute ：下标、切片、调用、属性引用
• (expressions…), [expressions…], {key: value…}, {expressions…} ：显示绑定或数组、显示列表、显示字典、显示设置

函数

• global x：函数中定义全局变量

模块

• dir()函数能够返回由对象所定义的名称列表
• 包
  建设你想创建一个名为“world”的包，其中还包含着”asia“、”africa“等其它子包，同时这些子 包都包含了诸如”india“、”madagascar“等模块。

-	<some folder present in	the	sys.path>/
    -	world/								
        -	__init__.py								
        -	asia/											
            -	__init__.py												
            -	india/																    -	__init__.py															-	foo.py								
            -	africa/												
                -	__init__.py												
                -	madagascar/																-	__init__.py														-	bar.py

数据结构

列表 list = []

元组 tuple = ()

字典 dict = {key1:value1,key2:value2}

序列

集合

其他

• startwith 方法用于查找字符串是否以给定的字符串内容开头

name = 'Swaroop'
if name.stratwith('Swa'):
    print('yes,the srting starts whit "Swa"')

• find方法用于定位字符串中给定的子字符串的位置。如果找不到相应的子字符串，find会返回 -1

面向对象程序设计

• self
• 类：class

class Perple:
    def say_hi(self):
        print('hello,how are you?')
p = Perple()
p.say_hi()

• __init__

class Perple:
    def __init__(self,name):
        self.name = name
    def say_hi(self):
        print('hello,my name is',self.name)
p = Person('Swaroop')
p.say_ji()

输出：
hello,my name is Swaroop

• 类变量与对象变量

class Robot:
	"""表示有一个带有名字的机器人"""
	population = 0
	def __init__(self, name):
		"""初始化数据"""
		self.name = name
		print("(Initializing{})".format(self.name))

		# 当有人被创建时，机器人将会增加人口数量
		Robot.population += 1

	def die(self):
		"""我挂了"""
		print("{} is being destroyed.".format(self.name))
		

		Robot.population -= 1

		if Robot.population == 0:
			print("{} was the last one.".format(self.name))

		else:
			print("There are still {:d} robots working.".format(Robot.population))

	def say_hi(self):
		"""来自机器人的诚挚问候   没问题，你做得到。"""
		print("Greetings,my masters call me {}.".format(self.name))

	@classmethod
	def how_many(cls):
		"""打印出当前人口数量"""
		print("We have {:d} robots.".format(cls.population))


droid1 = Robot("R2-D2")
droid1.say_hi()
Robot.how_many()

droid2 = Robot("C-3P0")
droid2.say_hi()
Robot.how_many()

print("\nRobots can do some work here.\n")

print("Robots have finished their work.So let's destroy them.")
droid1.die()
droid2.die()

Robot.how_many()

• 输出

(InitializingR2-D2)
Greetings,my masters call me R2-D2.
We have 1 robots.
(InitializingC-3P0)
Greetings,my masters call me C-3P0.
We have 2 robots.

Robots can do some work here.

Robots have finished their work.So let's destroy them.
R2-D2 is being destroyed.
There are still 1 robots working.
C-3P0 is being destroyed.
C-3P0 was the last one.
We have 0 robots.

• 继承
  面向对象编程的一大优点是对代码的重用(Reuse)，重用时一种实现方法就是通过继承(Inheritance)机制。

现在假设你希望编写一款程序来追踪一所大学里的老师和学生。有一些特征是他们都具有的，例如姓名、年龄和地址。另外一些特征是他们独有的,一如教师的薪水、课程与假期， 学生的成绩和学费。
你可以为每一种类型创建两个独立的类，并对它们进行处理。但增添一条共有特征就意味着 将其添加进两个独立的类。这很快就会使程序变得笨重。
一个更好的方法是创建一个公共类叫作SchoolMember,然后让教师和学生从这个类中继承(Inherit),也就是说他们将成为这一类型（类）的子类型，而我们就可以向这些子类型中添 加某些该类独有的特征。
这种方法有诸多优点。如果我们增加或修改了SchoolMember的任何功能，它将自动反映在子类型中。举个例子，你可以通过简单地向SchoolMember类进行操作，来为所有老师与学生添加一条新的ID卡字段。
不过，对某一子类型作出的改动并不会影响到其它子类型。另一大优点是你可以将某一老师或学生对象看作SchoolMember的对象并加以引用，这在某些情况下会大为有用，例如清点学校中的成员数量。
这被称作多态性(Polymorphism),在任何情况下，如果父类型希望，子类型都可以被替换，也就是说，该对象可以被看作父类的实例。
同时还需要注意的是我们重用父类的代码，但我们不需要再其它类中重复它们，当我们使用独立类型时才会必要地重复这些代码。
在上文设想的情况中,SchoolMember类会被称作基类(BaseClass)或是超类（Superclass)。Teacher和Student类会被称作派生类(DerivedClasses)或是子类(Subclass)。

class SchoolMember:
	"""docstring for SchoolMember"""
	def __init__(self, name, age):
		self.name = name
		self.age = age
		print('(Initialized SchoolMember:{})'.format(self.name))

	def tell(self):
		'''告诉我有关我的细节'''
		print('Name:"{}"Age:"{}"'.format(self.name,self.age),end=" ")


class Teacher(SchoolMember):
	"""docstring for Teacher"""
	def __init__(self, name, age, salary):
		SchoolMember.__init__(self,name,age)
		self.salary = salary
		print('(Initialized Teacher:{})'.format(self.name))

	def tell(self):
		SchoolMember.tell(self)
		print('Salary:"{:d}"'.format(self.salary))


class Student(SchoolMember):
	'''带表一位学生'''
	def __init__(self, name, age, marks):
		SchoolMember.__init__(self,name,age)
		self.marks = marks
		print('(Initialized Student:{})'.format(self.name))

	def tell(self):
		SchoolMember.tell(self)
		print('Marks:"{:d}"'.format(self.marks))

t = Teacher('李其昌',40,30000)
s = Student('刘巧月',25,75)

print()

members = [t,s]
for member in members:

	member.tell()

• 输出

(Initialized SchoolMember:李其昌)
(Initialized Teacher:李其昌)
(Initialized SchoolMember:刘巧月)
(Initialized Student:刘巧月)

Name:"李其昌"Age:"40" Salary:"30000"
Name:"刘巧月"Age:"25" Marks:"75"

它是如何工作的
要想使用继承,在定义类时我们需要在类后面跟一个包含基类名称的元组。然后,我们会注意到基类的__init__方法是通过self变量被显式调用的，
因此我们可以初始化对象的基类部分。下面这一点很重要，需要牢记——因为我们在Teacher和Student子类中定义了__init__方法，Python不会自动调用基类SchoolMember的构造函数，你必须自己显式地调用它。
相反，如果我们没有在一个子类中定义一个__init__方法,Python将会自动调用基类的构造函数。
我们会观察到,我们可以通过在方法名前面加上类名作为前缀，再将其传入self和其余变量中，来调用基类的方法。
在这里你需要注意,当我们使用SchoolMember类的tell方法时，我们可以将Teacher或Studtne的实例看作SchoolMember的实例。
同时，你会发现被调用的是子类型的tell方法，而不是SchoolMember的tell方法。理解这一问题的一种思路是Python总会从当前的实际类型中开始寻找方法，在本例中即是如此。
如果它找不到对应的方法，它就会在该类所属的基本类中依顺序逐个寻找属于基本类的方法,这个基本类是在定义子类时后跟的元组指定的。
这里有一条有关术语的注释——如果继承元组（Inheritance Tuple）中有超过一个类，这种情 况就会被称作多重继承（Multiple Inheritance）。
end参数用在超类的tell()方法的print函数中,目的是打印一行并允许下一次打印在 同一行继续。这是一个让print能够不在打印的末尾打印出\n(新行换行符）符号的小窍门。

输入与输出

• 可以用input()函数与print函数实现，对于输入，还有str(String,字符串)类的各种方法。例如rjust方法获得一个右对齐的指定宽度的字符串。

def reverse(text):
	return text[::-1]

def is_palindrome(text):
	return text == reverse(text)

something = input("Enter text:")
if is_palindrome(something):
	print("是回文序列")
else:
	print("不是回文序列")

• 输出

Enter text:sir
不是回文序列

Enter text:damad
是回文序列

注：使用切片反转文本

文件

Doem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
	use Python!
'''
f = open('Doem.txt','w')

f.write(Doem)

f.close()

# 如果没有指定，默认阅读(r)模式
f = open('Doem.txt')
while True:
	line = f.readline()

	if len(line) == 0:
		break

	print(line,end = '')

f.close()

• 输出

Programming is fun
When the work is done
if you wanna make your work also fun:
	use Python!

Pickle

• pickle.dump(obj, file, protocol=None,*,fix_imports=True) 序列化：以二进制储存
• pickle.load(file, *,fix_imports=True, encoding=”ASCII”. errors=”strict”)
  反序列化
• pickle标准模块，通过它可以讲任何纯python对象存储到一个文件中，并子啊稍后将其取回。这个叫持久的(Persistently)存储对象。

import pickle

shoplistfile = 'shoplist.data' #文件名称

shoplist = ['apple','mango','carrot']   

f = open(shoplistfile,'wb')  #打开并写入

pickle.dump(shoplist,f)     #序列化
f.close()

del shoplist     #销毁shoplist

f = open(shoplistfile,'rb')   #读取

storedlist = pickle.load(f)   #反序列化

• 输出

['apple', 'mango', 'carrot']

• 要想将一个对象存储到一个文件中，我们首先需要通过open以写入(write)二进制(binary)模式打开文件，然后调用pickle模块的dump函数。这一过程被称作封装(Pickling)接着，我们通过pickle模块的load函数接收返回的对象。这个过程被称作拆封(Unpickling)

Unicode

• Unicode字符串转换至一个能够被发送和接受的格式，叫做“utf-8”

import io

f = io.open("abc.txt","wt",encoding = "utf-8")
f.write(u"Imagine non-English language here")
f.close()

text = io.open("abc.txt",encoding = "utf-8").read()
print(text)

异常

处理异常

try:
	text = input('Enter something -->')
except EOFError:
	print('Why did you do an EOF on me?')
except KeyboardInterrupt:
	print('You cancelled the openation.')
else:
	print('You entered {}'.format(text))

抛出异常

class ShortInputException(Exception):
	"""docstring for ShortInputException"""
	def __init__(self, length, atleast):
		Exception.__init__(self)
		self.length = length
		self.atleast = atleast

try:
	text = input('Enter something -->')
	if len(text) < 3:
		raise ShortInputException(len(text),3)
except EOFError:
	print('why did you do an EOF on me?')
except ShortInputException as ex:
	print(('ShortInputException:The input was'+'{0} long,expect at least {1}').format(ex.length,ex.atleast))	
else:
	print('No exception was raised')

• 输出

Enter something -->a
ShortInputException:The input was1 long,expect at least 3

Enter something -->abc
No exception was raised

Try…Finally

import sys
import time

f = None
try:
	f = open("Doem.txt")

	while True:
		line = f.readline()
		if len(line) == 0:
			break
		print(line,end = '')
		sys.stdout.flush()
		print('Press ctrl+c now')
		time.sleep(2)
except IOError:
	print("Could not find file Dome.txt")
except KeyboardInterrupt:
	print("!!You cancelled the reading from the file")
finally:
	if f:
		f.close()
	print("(Clean up:Closed the file)")

• 输出

Programming is fun
Press ctrl+c now
When the work is done
Press ctrl+c now
if you wanna make your work also fun:
Press ctrl+c now
	use Python!
Press ctrl+c now
(Clean up:Closed the file)

with语句

import re
with open('Doem.txt', 'w') as f:
   f.write('hello world')

• 不用关闭，已完成写入操作并关闭。

标准库

sys模块

• sys.version_info，它提供给我们版本信息。

>>> import sys
>>> sys.version_info
sys.version_info(major=3, minor=6, micro=4, releaselevel='final', serial=0)
>>> sys.version_info.major==3
True

日志模板

import os
import platform
import logging

if platform.platform().startswith('Window'):
	logging_file = os.path.join(os.getenv('HOMEDRIVE'),os.getenv('HOMEPATH'),'test.log')
else:
	logging_file = os.path.join(os.getenv('HOME'),'test.log')

print("Logging to",logging_file)

logging.basicConfig(
	level = logging.DEBUG,
	format = '%(asctime)s : %(levelname)s : %(message)s',
	filename = logging_file,
	filemode='w'
	)	
logging.debug("Srart of the program")
logging.info("Doing something")
logging.warning("Dying now")