python笔记

字符串类型：

　　成员运算符：

　　s1 = ‘hi’

　　print('hi' in s1)

　　索引和切片 正向递增(0~len(s)-1) 反向递减(-1~-len(s))

　　s = 'python'

　　print(s[0])   print(s[1:3])   print(s[-3:-1])   print(s[-1:-3:-1])

　　print(s[-1])   print(s[:3])

　　函数：

　　print(s[len(s)-1])字符串长度   print(max(s))字符串的最大值   print(min(s))最小值  print(s.index('h'))某一字符串的索引   print(s.count('n'))总的字符个数

Python的基本数据类型

　　布尔类型：True   False

　　数字类型：int   float

　　　　运算符:   单目运算符：~，+, -

　　　　　　　　算术运算符：** / * // % + -

　　　　　　　　位置运算符：& | ^ >> <<

　　　　　　　　关系运算符：> >= < <= == !=

　　　　　　　　赋值运算符：= += -= /= *= //= %= **=

　　　　　　　　身份运算：is is not

　　　　　　　　成员运算：in not in

　　　　　　　　逻辑运算符： not and or

　　函数：int() 定义整型或转为整型

　　　　　pow()  (x,y)返回x的y次方

　　　　　divmod()  （x,y）x=a//b,y=a%b

　　　　　abs() 去绝对值

python中的类型

　　内置类型: 布尔类型：True False

　　　　　　   数字类型：int float

　　　　　　　文本类型：str

　　　　　　　序列类型：list tuple range（可以遍历）

　　　　　　　集合类型：set（可以去重）

　　　　　　　映射类型：dict

for...in循环

　　for i in range(10):

　　　　print(i)

　　i = 0

　　while i < 10:

　　　　print(i)

　　　　i += 1

　　for i in range(5, 10):

　　　　print(i)

　　i = 5

　　while i < 10:

　　　　print(i)

　　　　i += 1

　　for i in range(10,5,-1):

　　　　print(i)

　　i=10

　　while i > 5:

　　　　print(i)

　　　　i-=1

　　for i in 'python':

　　　　print(i)

　　控制语句:if,elif,else

　　　　　　[for i in range(0,100) if i % 2 == 0]

　　打印99乘法表:

　　　　for i in range(1, 10):

　　　　　for j in range(1, i+1):

　　　　　　　print('{}*{}={:<2}'.format(j, i, j*i), end=' ')

可变的序列类型：列表list

　　l = []   l = [1,2,3,'hello', [11,22]]   ls = list('hello')   ls2 = list(range(100))

　　索引：print(l[0])   print(l[4][0])

　　切片：print(l[0])   print(l[4][0])

　　增加：l[1:1] = [100]   l.append(110)   (l.insert(2, 119)指定位置插入）

　　删除：l[1:3] = []   l.pop(3)按索引删除   l.remove([11,22])按具体值删除

　　修改：l[0] = 120   l[1:3] = [9,8,7,6]   l += ['a', 'b', 'c']列表可以直接加   l.extend([607, 478])在列表末尾追加

　　查：for i in l：                      for i in range(len(l)):

　　　　　　print(i)　　　　　　　　print(l[i])

　　倒序：l.reverse()   l.sort(reverse=True)

字符串 将用户输入字符串中的大写成员转小写，小写成员转大写

　　ord() chr()

s = input('str:')

new_str = ''
for i in s:
	if 'a' <= i <= 'z':
		# new_str += chr(ord(i) - (ord('a')-ord('A')))
		new_str += i.upper()
	elif 'A' <= i <= 'Z':
		# new_str += chr(ord(i) + (ord('a')-ord('A')))
		new_str += i.lower()
	else:
		new_str += i
print(new_str)

　有序的不可变的序列类型:　tuple 元组

　　定义：t = ()

　　t = tuple([1,2,3,4, 'hello'])

　　索引 切片：print(t[0])   print(t[::-1])

　　成员运算符：for t in t2:     print(max(t))   print(min(t))   print(len(t))   print(t.index(7))   print(t.count(7))

python3的字符串:

　　文本字符串(str)   二进制字符串(bytes)

　　编码: str--->bytes   string.encode(encoding = 'utf-8')

　　解码:bytes--->str   bytestring.decode(encodeing = 'utf-8')

深复制和浅复制：

　　对于非复合类型 深复制和浅复制无差别：a = 10   b = copy.copy(a)

　　对于可变复合类型 浅复制不会复制子对象,而深复制会:a = [1,2,[100, 200]]   b = copy.copy(a)   b = copy.deepcopy(a)

字典(dict):无序的可变的, 有key=value组成的

　　定义：d = {'name':'python', 'age':20}   d2 = dict(name='python', age=20)   

　　　　    d3 = dict([('name', 'python'), ('age', 20)])   d4 = dict(zip(['name', 'age'], ['python', 20]))

　　通过key得到成员: key唯一的,不可变的：print(d4['name'])     d4['name'] = 'guido' 

　　获得所有的key, values, item：print(d4.keys())   print(d4.values())   print(d4.items())

　　遍历：for i in d4.keys():                               for i,v in d4.items():

　　　　　　print(d4[k])                                             print(i,v)

　　增加:d4['height'] = 180          d4.update(id=5, score=100)

　　删除:d4.pop('id')

生成器:l = [i for i in range(100)]

　　节省空间:g = (i for i in range(100))

抓了a,b,c,d四名犯罪嫌疑人，其中有一人是小偷，审讯中：•a说我不是小偷；•b说c是小偷；•c说小偷肯定是d；•d说c胡说！其中有三个人说的是实话，一个人说的是假话，请编程推断谁是小偷。

for thief in ('a', 'b', 'c', 'd'):
	if ((thief != 'a') + (thief == 'c') + \
		(thief == 'd') + (thief != 'd')) == 3:
		print('小偷是{}'.format(thief))
		break

斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……。求斐波那契数列的前20项

a = 0
b = 1

print(a, b, end=' ')
for i in range(18):
	c = a+b
	print(c, end=' ')
	a = b
	b = c
print()

列表生成式

　　练习1:有字符串s1 = 'ABC' s2 = 'xyz' 生成一个列表，列表中的元素是['Ax', 'By', 'Cz']:           l = [x+y for x in 'ABC' for y in 'xyz']

　　有列表l = ['Hello', 'EVERYone', 'goOd', 'AFTErNooN']   使用一条语句将列表中变成由所有小写字母组成:   

　　 l = ['Hello', 'EVERYone', 'goOd', 'AFTErNooN']

　　 l = [x.lower() for x in l]

集合(set):无序的不重叠的可变的:可去重复

　　定义：st = {1,2,3,4}

　　去重：l = [1,2,3,3,2,34,1,23]    l = list(set(l))   

　　st2 = {2,1,8,9,4}：print(st & st2) # 交集    print(st | st2) # 并集    print(st - st2) # 差集    print(st ^ st2) # 交叉差集

字符串方法补充：

　　居中填充：s = 'python'   s = s.center(20, '-')

　　统计出现个数：print(s.count('th', 0, 3))

　　找到子串：ind = s.find('th')

　　按进制输出：s = '{:b}'.format(10)    s = '{:o}'.format(10)    s = '{:x}'.format(10)

　　字符串拼接：

import random
s = 'beautiful'
l = list(s)
random.shuffle(l)
s = ''.join(l)
print(s)

　　替换：s = s.replace(',', '.')

　　切割：res = s.split('.')a

参数类型:位置参数：

def max2num(x, y):
	print(x, y)
	return x if x > y else y

　　

 

　　　　  默认参数：

def power(x, y=2):
	s = 1
	while y:
		s *= x
		y -= 1
	return s

　　默认参数的默认值最好不是可变类型：

def add_end(l=[]):
	l.append('python')
	return l


def add_end(l=None):
	if l == None:
		l = []
	l.append('python')
	return l

　　　　 可变参数：

def sumall(*numbers):
	# print(type(numbers))
	s = 0

	for i in numbers:
		s += i

	return s

　　位置参数在可变参数后：

def test(*args, n=100):
	print(n, args)

　　　　  关键字参数：

def stuinfo(name, age, city='北京', **kw):
	print(name, age, city, kw)

　　命名关键字参数：

def stuinfo2(name, age, city='北京', *, height, gender):
	print(name, age, city, height, gender)	

　　多种参数类型混合使用 位置参数在第一位，关键字参数一定在最后：

def test2(locate, *args, name, age, default=100, **kw):
	print(locate, args, default, name, age, kw)


res = max2num(10, 20)
print(res)

res = max2num(y=100, x=200)
print(res)

　　局部变量、全局变量：

def test():
	# 声明使用全局变量x
	global x
	x = 100
	y = 300	 # 局部变量:作用域和生存周期仅在从定义开始到函数结束


x = 200 # 全局变量:作用域从定义开始到进程结束
test()
print(x)

　　递归调用:

　　　　定义：在函数内调用函数本身

　　　　使用条件（方法）：1，找到终止条件。2，找到递归条件

def sumn(n):
	'''
		n的前n项和
	'''
	if n == 0:
		return 0
	return n + sumn(n-1)





Fibnacci数列的第n项
'''
def fibnacci(n):
	if n <= 0:
		return False 
	if n == 1:
		return 0 
	elif n == 2:
		return 1 
	return fibnacci(n-1) + fibnacci(n-2)



print(sumn(10))
for i in range(1, 21):
	print(fibnacci(i), end = ' ')
print()

　　装饰器(decorator):

　　　　作用：修饰函数

　　　　闭包:函数内有一个内嵌函数，内嵌函数可以使用外部函数的局部变量

import functools

def decorator(f):
	@functools.wraps(f) # 此装饰器作用是将f的函数名赋值给wrapper
	def wrapper(*args, **kw):
		'''装饰器的内部函数'''
		# print(args, kw)
		print('hello python')
		# print(f.__name__)
		return f(*args, **kw)
	return wrapper

@decorator 
def show(name1, name2):
	'''验证装饰器功能的小函数'''
	print('hello %s and %s' % (name1, name2))
	return 100

print(show.__name__)
print(show.__doc__)
res = show('王涛', '任海') # show = decorator(show)
print(res)

　　带参数的装饰器

import functools

def log(text, text2):
	def decorator(f):
		@functools.wraps(f)
		def wrapper(*args, **kw):
			print('log', text, text2)	
			print('这个装饰器好吧?')
			return f(*args, **kw)
		return wrapper
	return decorator


@log('argument', 'haha')
def now():
	print('2018-12-12')

now() # now = log('argument')(now)

　　高阶函数：

　　　　定义：以函数为参数的函数

　　map：

def test(n):
	return n ** 3

# g = map(test, (1,2,3,4))
g = map(lambda x : x**3, (1,2,3,4))
print(type(g))

　　reduce:

def add(x, y) :            # 两数相加
 return x + y

reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数

　　

　　filter:

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

　　

　　sorted:

a = [5,7,6,3,4,1,2]
 b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
 b
[1, 2, 3, 4, 5, 6, 7]

　　生成器(generator):　　

　　迭代器(Iterator):　　

　　　　next()得到成员的:generator

　　可迭代(Iterable):能用for遍历的:str, list, tuple, dict, set, generator, range

def fib(n):
	a, b = 0, 1
	while n > 0:
		# print(b)
		yield b # 随着生成器调用next方法，得到yield的值
		a, b = b, a+b
		n -= 1
	return 'done'

g = fib(10)
print(g)

　　匿名函数：适合函数功能简洁的

f = lambda x : True if x % 2 == 0 else False
print(type(f))

　　验证模块的使用:私有函数(_或__开头的函数)导入

　　time模块

import time

# 时间戳
tm = time.time()
# 时间结构
ltime = time.localtime()
print(ltime.tm_year)
# 时间字符串
str_time = time.strftime("%Y-%m-%d %H:%M:%S", ltime)
print(str_time)

　　面向对象(oop):

　　　　　　类：抽象概念，类型（人类，动物类）

　　　　　　对象：实际物体，类实例化对象（某一个人，某一只狗）

　　　　　　属性：描述类的-->类属性（实例对象都能使用，都具有）

　　　　　　　　　描述对象的-->实例属性（只有实例的当前个体可以使用）

 面向过程描述学生的成绩
d = {'miguitian':80, 'yangzhichao':88, 'zhangxue':100, 'liuhongsheng':12}

# 抽象类型
class Student(object):
	count = 0 # 类属性：类名.属性名
	def __init__(self, score): # --->构造函数:实例化对象时自动调用的（一般情况必须有）
		# print('__init__ is called')
		# self : 当前对象
		self.score = score
		Student.count += 1

	# 实例方法
	def setName(self, name):
		if 1 < len(name) < 32:
			self.name = name
			return True
		else:
			return False

	def run(self):
		print('%s is running' % self.name)

	def __del__(self): # 析构方法:对象销毁的时候自动调用调用
		print('delete.....')
# 实例化对象
s1 = Student(100)
# 访问对象的属性
print(s1.score)
s1.name = 'chenyunliang'
print(s1.name)

del s1

s2 = Student(98)
print(s2.score)

# 调用方法
s2.setName('python')
print(s2.name)

s2.run()

print('学生对象有%d个'%Student.count)

　　私有方法：

def __privateFun(self):
		print('private....')

	def __del__(self): # 析构方法:对象销毁的时候自动调用调用
		print('delete.....')
# s1.__privateFun()
s1._Student__privateFun()

　　继承

class Animal(object):
    def __init__(self, name, age=1, color='white'): # 重写
        self.name = name
        self.age = age
        self.__color = color  # _Animal__color

    def show(self):
        print(self.name, self.age, self.__color)


class Dog(Animal):
    def __init__(self, name, age, breed):
        # 调用父类方法
        # Animal.__init__(self, name, age)
        # super(Dog, self).__init__(name, age)
        super().__init__(name, age)
        self.breed = breed
    
    def show(self):
        Animal.show(self)
        print('品种是%s' % self.breed)


class Cat(Animal):
    '''
    def getColor(self):
        return self.__color # 子类中不能直接访问继承的私有属性
        # return self._Animal__color
    '''
    pass
animal1 = Animal('花花')
animal1.show()

d1 = Dog('旺财', 1, '哈士奇')
d1.show()

cat1 = Cat('来福', 2, '花色')
cat1.show()

print(cat1.getColor())

多态

class Animal(object):
	def run(self):
		print('animal is running')
class Dog(Animal):
	def run(self):
		print('Dog run fast')
class Rabbit(Animal):
	def run(self):
		print('Rabbit jump...')
class Cat(Animal):
	pass
class Timer(object):
	def run(self):
		print('the time is running')
# 多态：同一种类型，不同的表现形式
def runTwice(animal):
	animal.run()
	animal.run()
a = Animal()
rabbit = Rabbit()

runTwice(a)
runTwice(rabbit)

# 鸭子类型(不同物体有一样的表现形式)
tm = Timer()
runTwice(tm)

限制实例属性

class Person(object):
	__slots__ = ('name', 'age') # 只允许有'name' 'age'属性
'''
per1 = Person()
per1.name = '小明'
print(per1.name)
per1.height = 167 # 不允许
'''

class Student(object):
	def __init__(self, age):
		self.__age = age
	'''
	def setScore(self, score):
		if 0 <= score <= 100:
			self.__score = score
			return 'ok'
		else:
			return 'error'
			
	def getScore(self):
		return self.__score
	'''

	@property # 访问器 可以单独存在。作用：可以把定义的函数当做属性访问
	def score(self):
		print('getter is called')
		return self.__score

	@score.setter # 设置器 不单独存在，一定要有property作用：可以直接给函数赋值
	def score(self, score):
		print('setter is called')
		if 0 <= score <= 100:
			self.__score = score
			return 'ok'
		else:
			return 'error'

	@ property
	def age(self):
		return self.__age


s1 = Student(20)
'''
if s1.setScore(10) == 'ok': # s1.score= 100
	print(s1.getScore())
'''
s1.score = 100
print(s1.score)
print(s1.age)

　　元类(metaclass)

　　多继承:python支持，但不建议使用

class A(object):
	def run(self):
		print('run A run')
class B(A):
	def run(self):
		super().run()
		print('run B run')
class C(A):
	def run(self):
		super().run()
		print('run C run')
class D(B, C):调用super()时遵循广度优先的原则
	pass

c = C()
c.run()
# 获取类或者对象的方法和属性
print(dir(C))
# 获取类的继承顺序
print(C.__mro__)查看继承顺序

d = D()
d.run()
print(D.__mro__)　

python魔法方法

class Student(object):
	def __init__(self, name = 'python'):
		self.__name = name
        def __str__(self):
		'''打印本类对象时，自动调用'''
		return 'hello, %s' % self.__name
　　　　　def __repr__(self):
		'''在解释器环境下直接输出本对象，自动调用的方法'''
		return self.__str__()

	def __len__(self):
		'''调用len函数的时候自动调用的方法'''
		return 100

	def __call__(self):
		'''调用本类对象的时候自动调用的方法'''
		print('Student object name:%s' % self.__name)

print(dir(Student))

s = Student()
print(s)

print(len(s))

s()

    

　　使自己定义的类成为可迭代类型并且可以索引的方法：

class Fib(object):
	cnt = 0
	def __init__(self):
		self.a = 0
		self.b = 1

	def __iter__(self):
		'''返回可迭代对象'''
		return self

	def __next__(self):
		'''随着循环自动调用的'''
		self.a, self.b = self.b, self.a+self.b
		
		if self.a >= 100:
			'''循环遍历终止'''		
			raise StopIteration()
		Fib.cnt += 1（使用类的属性必须加类名）
		
		return self.a
　　　　　def __len__(self):
		return Fib.cnt

	def __getitem__(self, n):
		'''索引时自动调用的方法'''
		if isinstance(n, int):
			a, b = 0, 1
			while n >= 0:
				a, b = b, a+b
				n -= 1
			return a	

		if isinstance(n, slice):
			'''切片类型 start:end'''
			if n.start == None:
				start = 0
			else:
				start = n.start	
			if n.stop == None:
				return 'error'
			stop = n.stop
			l = []
			for i in range(start, stop):
				l.append(self[i])
			return l
f = Fib()

print(dir(f))

for i in f:
	print(i, end=' ')
print()

print(len(f))

for i in range(20):
	print(f[i], end=' ')
print()

print(f[0:3])
print(f[1:10])

枚举类：防止其中的变量值改变主要用在Menu中

from enum import Enum, unique

@ unique # 防止枚举成员的重复
class Menu(Enum):
	INSERT=1
	DELETE=2
	UPDATE=3
	SHOW=4
	# CHOOSE=4

print(Menu.INSERT.value)
# Menu.INSERT.value = 2
print(Menu['INSERT'])