By

Contents
  1. 1. PEP8规则
  2. 2. 等腰三角形的输出
  3. 3. 递归函数
  4. 4. 面向对象
  5. 5. 私有属性和私有方法
  6. 6. 类属性和实例属性
  7. 7. 类方法和静态方法
  8. 8. 简单工厂模式
  9. 9. new方法
  10. 10. 异常
  11. 11. 给程序传参
  12. 12. 列表推倒式
  13. 13. 导入模块
  14. 14. ==和is
  15. 15. 深拷贝和浅拷贝
  16. 16. 进制
  17. 17. 属性property

PEP8规则

  1. 变量命名最好是s_server，而不是大驼峰sServer或者带下划线的大驼峰s_Server
  2. 导入模块时，尽量不要用form xxx import *，用的是import xxx

取整(就是取商)
11//5 --> 5

取余(就是取余数)
11%5 --> 1

变量就是内存中的一段存储空间

有关导入模块
当交互模式下，修改py文件的代码，之后需要用reload重新加载模块文件，不过可以用一个方法来改变
exec(open('模块文件.py').read())

等腰三角形的输出

while输出三角形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
i = 0
while i < 5:
	j = 0
    while j <= i:
    	print("* ", end="")
        j += 1
    print("\n")
    i += 1
i = 0
while i < 4:
	j = 0
    while j < (4-i):
    	print("* ",end="")
    	j += 1
    print("\n")
	i += 1

带空白字符的字符串不是空字符串，在布尔环境下返回True，也就是返回一个值
在交互环境下

1
2
3
4
5
if "":
	print("hello")	# 这样是不会有返回值的
if " ":
	print("hello")	# 这样的返回值是hello

break用于结束当前循环，continue用于结束本次循环，进入下一次循环

匿名函数lambda，交互模式下

1
2
3
add = lambda x,y:x+y
add(2,4)
输出值：6

递归函数

递归函数，自己调用自己，可能因判断条件有误，而导致无限循环
应有一个基准条件和递归条件，交互模式下

1
2
3
4
5
6
7
8
9
10
# 设计一个从1累加到100的递归函数
def sum_n(n, sum=0):
	if n < 1:	# 基准条件 n < 0
    	return sum	# 当条件满足，不再调用自己，返回一个值
    else:	# 当递归条件 n >= 1
    	sum += n
        return sum_n(n-1, sum)	# 此时不满足基准条件，自己调用自己，调用sum_n函数
sum_n(100)
5050


面向对象

面向对象编程(OOP,面向对象程序设计)

new方法直接创建对象，init是对 对象里面的东西初始化
Python中万物皆对象

经典类存在于python2中，在python3中，所有的类默认继承自object，python3中只有新式类，object是所有类的父类。

不可变类型的全局变量在函数中不加global声明，就无法修改，并且报错

私有属性和私有方法

1. 私有属性，就是函数中带有两个下划线的变量名，子类不能调用私有属性

1
2
3
class A(object):
	def __init__(self):
    	self.__name = "老王"	#私有属性

2. 私有方法，就是函数中带有两个下划线的方法，子类不能调用私有方法

1
2
3
4
5
6
class A(object):
	def __init__(self):
    	self.__name = "老王"	#私有属性
	def __test__(self):	#私有方法
    	print("---test_1---")

类属性和实例属性

1. 实例属性就是相当于平常定义的类，init方法里面的属性，实例属性通过对象来调用

1
2
3
4
class Car(object):
	def __init__(self):
		# 下面就是实例属性
		self.name = "che"

2. 类属性就是一个类里面定义的一个属性，类属性通过类名来调用(如果这个num=0没有放到一个方法中，那么这个变量就是这个类对象的属性，称为类属性；它的特点，所有通过这个类创建出来的对象，都可以使用这个属性)

1
2
3
4
5
6
7
class Car(object):
	# 下面这个就是类属性
	num = 0
	def __init__(self):
		# 下面就是实例属性
		self.name = "che"


类方法和静态方法

修改类属性的值需要在类属性的下面用到@classmethod，这个就叫类方法

1
2
3
4
5
6
7
8
9
10
11
12
13
# 原无法修改类属性的时候
class Car:
	num = 0
    def setNewnum(self, num):
    	self.num = num
# 现可以修改类属性的时候
class Car:
	num = 0
    @classmethod	# 类方法
    def setNewnum(cls, num):
    	cls.num = num

如果一个方法前面写了@staticmethod，那么这个方法就叫做静态方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Car:
	num = 0
    @classmethod	# 类方法
    def setNewnum(cls, num):
    	cls.num = num
	@staticmethod	# 静态方法
    def printCarsNum():
    	print(Car.num)
bmw = Car()
Car.num += 1
benz = Car()
Car.num += 1
Car.printCarsNum()

简单工厂模式

模式就是通俗地说当遇到什么样的问题，就用什么样的解决方式来解决它。
定义一个函数，函数接收参数，根据接收参数的不同，生成对象也是不同的，这种方式叫简单工厂模式。工厂函数和工厂类

new方法

new方法就是创建对象，init对对象的属性初始化
单例模式需要用到new方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Animal(object):
    __instance = None
    __inited = None
    def __new__(cls, *args):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance
    def __init__(self, name):
        if Animal.__inited is None:
            self.name = name
            Animal.__inited = True
dog = Animal("xiaogou")
cat = Animal("xiaomao")
print(id(dog))
print(dog.name)
print(id(cat))
print(cat.name)

输出结果是：

1
2
3
4
139722319965824
xiaogou
139722319965824
xiaogou

异常

1
2
3
4
5
6
7
8
9
try:
	print(a)
	print("---1---")
except:
	print("产生了错误...")
	if self.xxx:
		print("捕获开启")
	else:
		raise 类名A	# 重新抛出异常，抛出的异常叫 类名A

all限制模块的导入，如果定义了all，那么导入模块只能导入跟all相对应的，如all = [“test1”]

包就是py文件

给程序传参

1
2
import sys
print(sys.argv)

列表推倒式

num = [x for x in range(1,11)]
也可以在列表推倒式里面添加条件
num = [x for x in range(1,11) if x%2!=0]
Get
num = [[x,x+1,x+2] for x in range(1,11,3)]

1
2
a = [1,2,3,4,5,6,7,8,9,10,11,12]
num = [[x,x+1,x+2] for x in a[::3]]

导入模块

搜索模块路径

1
2
3
import sys
sys.path
sys.path.append("路径")    #给path增加地址

1
2
3
from imp import *	#导入重新加载的模块功能
reload(模块)    #重新加载模块
exec(open('模块文件.py').read()) -->  解决重新加载模块的问题，由于某些问题不推荐使用

==和is

1
2
3
4
a = [11, 12]
b = [11, 12]
a == b    #True，数值相同
a is b    #False，内存地址不同，返回false

深拷贝和浅拷贝

深拷贝

1
2
import copy
a = copy.deepcopy(b)    #深拷贝，拷贝内存中的数据到新的内存中，就是相当于重新写了一份数据

浅拷贝

1
2
3
a = b    #浅拷贝，类似于只拷贝引用，指向同一内存地址
copy.copy    #根据拷贝的数据类型(可变，不可变)分拷贝情况，拷贝的是引用，如果一个列表删掉了里面的元素列表，那么另一个列表里面的数据不会变，如果是修改的话，同样都会变

进制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
正数：原码=反码=补码
负数：原码，反码：负数不变，后面取反，补码：最后位+1
补码转原码：反码 --> 补码
bin()二进制，oct()八进制，hex()十六进制，int("数值"，几进制)
>>右移，<<左移
9取反得-10
9的二进制是0000 1001，，，，后四位的值为 8 4 2 1，，，它的值相加是8+0+0+1 = 9
之后补码取反，1111 0110
再之后负数位不变，其他位取反+1，1000 1001 + 1，，，等于 1000 1010 = -10

属性property

property的作用:相当于把方法进行了封装, 开发者在对属性设置数据的时候更方便
property升级setter方法和getter方法
方法一：property(getter, setter)
方法二：@property #装饰器

函数中存在yield的就是生成器