红黑树

目录

1. 变量
2. 字符串
3. 数字
4. 列表
5. if语句
6. 字典
7. 用户输入和循环
8. 函数
9. 类
10. 文件和异常
11. 测试函数

解决问题的方法有很多种，在效率和时间之间取其平衡。

变量

Python变量的命名一般使用字母数字以及下划线，开头只能是字母或者下划线。

字符串

接下来介绍第一种数据类型，字符串，在任何一种语言中，字符串都是一个非常常用的数据类型，接下来我们主要记录字符串的使用注意事项，以及常用的字符串处理函数。

1. title() ： 首字母大写
2. upper():全部大写
3. lower():全部小写
4. 使用 ‘+’ 合并拼接字符串
5. 使用制表符和换行符添加空白’\t \n’
6. strip():删除两端空白
7. rstrip():删除右边空白
8. lstrip():删除左边空白
9. 在使用字符串的时候，如果字符串中包含单引号，定义的字符串最好使用双引号
10. str(param)：强制类型转换

数字

在数字相关的内容中，包含整数和浮点数

在Python中，两个乘号表示乘方运算。

浮点数最好不要用来进行等号的比较，因为在所有的语言中，浮点数的存储都不是很精确。

字符串拼接数字，最好对数字进行强制类型转换。

Python中使用 ‘#’ 进行注释

列表

在Python中，使用方括号来表示列表，并用逗号来分隔其中的元素。

1
2
bicycles = ['trek','dfd','fte','wad','hre','tws']
print(bicycles[0]) #trek

python中，列表的访问下表从0开始，从最后以为开始访问 ，-1表示访问最后以为元素，前面的以此类推。

列表的修改，可以直接对列表中的值进行修改。

往列表中，添加元素：

1. append(param) 在末尾添加元素
2. insert(index,param) 往指定位置添加元素

删除列表中的元素:

1. del bicycles[0] 删除指定列表中的指定元素
2. pop() 列表中的最后一个元素，并返回
3. pop(index) 删除指定位置的元素，并返回
4. remove(value) 根据值进行删除

组织列表

1. sort() 对列表进行排序，该变了列表,可带参数reverse,反向
2. sorted 不改变列表 ，可带参数reverse,反向
3. reverse() ：函数表示倒置
4. len(list) ：返回列表长度

操作列表：

1. for item in items:
2. 创建数值列表： range(1,5) 左闭右开： for value in range(1,5),其中使用list函数可以直接将range函数的结果转换成list
3. min,max,sum求数值列表的统计计算
4. 列表解析 squares = [value ** 2 for value in range(1,11)],它会将for循环和创建新元素的代码合并成一行，并自动附加新元素。
5. 切片： squares[0:3] 获取squares中的0到3的元素。[1:],[:],[-3:],1到最后，全部，倒数第三到最后一个。
6. 利用切片可以进行列表的深拷贝，切片返回的是另一片存储空间的值

与列表很相近的就是元组，使用小括号进行表示，但是小括号里面的值不放发生改变

if语句

1. ==：相等
2. !=：不等
3. and 同时满足
4. or 或者
5. 检查特定元素是否在列表中,使用in，不在使用not in。
6. 确认列表不是空的，直接if列表就可以。

1
2
3
4
5
6
7
8
if condition :
	语句
else:
	语句
items = ["a","b","c"]
if	"a" in items:
if "a" not in items:

字典

在Python中，字典非常想lua中的table。使用大括号括起来的键值对。

1. 字典.items()，可以同时得到key值和value值。
2. keys()，访问key值。
3. values(),访问value值，给values加上函数set()，集合函数，不会出现重复的值
4. 字典类似于table可以进行嵌套

用户输入和循环

使用input来提示用户输入信息，返回的值可以存在一个变量内。

1
2
message = input("please input:)
print(message)

在循环方面除了可以使用for以外，我们还可以使用while，while里面可以使用break和continue。

while和列表可以配套使用，while key值 in list: 进入循环。

函数

在Python函数的定义使用 def funName(): 其中括号中可以带参数。

关于参数的传递，除了位置实参之外还可以使用关键字实参，即为了让形参取到正确的值，除了让实参的顺序对应上形参的顺序之外，还可以使用，键值对的方式，键值是形参的名字，值就是实参。

在Python中，可以给参数默认值，但是一般带默认值的形参都要放到参数的最后。

在Python中，使用return返回任意类型的数值。

*参数名 ：传递任意数量的实参。这是任意数量的实参会被放到这个‘参数名’中，这个参数名是一个元组。

**参数名：创建一个空的字典，将参数中的键值对实参放到里面去。

模块的导入：

import 文件名 导入整个文件

from moduleName import functionName 导入某个模块的某个函数

from moduleName import functionName as newName 给导入的函数重新命名，同样也可以给模块重新命名

from moduleName import * 导入模块内的所用函数

不推荐导入一个模块快的所有函数，在这里导入真个模块我们可以通过模块名加点来访问其中的函数，但是直接导入的函数，就类似于把这个函数直接写到了这个模块，这样可能会引起函数命名相同，导致意料之外的错误。

类

1
2
3
4
5
6
7
8
9
10
11
class Dog():
	def __init(self,name,age)
		self.name = name
		self.age = age
	
	def sit(self)
		print(self.name.title() + " is sitting now.")

class GoldenDog(Dog)
	def __init__(self,name,age)
		super().__init__(name,age)

在Python中，类的首个字母要大写。

其中__init__方法是类的构造函数，加上两个下划线是表示这是Python中的默认方法和普通方法做个区分。

在定义方法的时候，会默认加上self参数，这个表示类本身。

类的创建，直接调用类名(参数):这里面的参数不用传递self。

访问属性或者调用方法，对象点就可以访问。

在使用继承的时候，需要在括号中加上父类，并且在构造函数中，通过super()函数来调用父类的构造函数。

一个模块里面可以写多个类，所以导入类和导入方法类似。可以同时的导入多个类。

文件和异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
with open(filepath) as file_object:
	contents = file_object.read()
	print(contents)
	for line in file_object:
		print(line)
	lines = file_object.readlines()
	# liens是一个列表

with open(filepath,'w') as fileObject: # 全部重新写入
	fileObject.write("i love programming")

with open(filepath,'a') as fileObject: # 附加写入
	fileObject.write("i love programming")

# 异常的捕捉,异常的使用可以避免程序崩溃
try:
	code
except error:
	code

在分析文件的时候可以使用split()函数来对字符串进行分割。

数据的存储使用 json.dump() 和 json.load()

dump函数有两个参数一个是 数据，另一个是文件路径，load的参数就是文件路径，然后将文件内容加载就好。

测试代码

1
2
3
4
5
6
import unittest
from nameFunction import getName
class NamesTestCase(unittest.TestCase):
	def test_first(self):
		formatName = getName("janis","jopin")
		self.assertEqual(formatName,"Janis Jopin")

各种断言的方法：

1. assertEqual(a,b)
2. assertNotEqual(a,b)
3. assertTrue(x)
4. assertFalse(x)
5. assertIn(item,list)
6. assertNotIn(item,list)

boss

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
---
--- Generated by EmmyLua(https://github.com/EmmyLua)
--- Created by jow.
--- DateTime: 2018/12/24 23:33
---

local m = 7
local p = { 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 }
local q = { 1, 1, 1, 1, 1, 1, 1 }

local e = {}
 
local cal
cal = function(p, q)
    local dim = q
    if #dim == 1 then
        if dim[1] == 0 then
            return 0
        elseif dim[1] == 1 then
            return 1 / p[1]
        else
            if e[{ p, { dim[1] - 1 } }] then
                return p[1] * e[{ p, { dim[1] - 1 } }]
            end
            return p[1] * cal(p, { dim[1] - 1 })
        end
    end
    local downDim = {}
    local dowmP = {}
    for i, v in ipairs(dim) do
        if v ~= 0 then
            table.insert(downDim, v)
            table.insert(dowmP, p[i])
        end
    end
    local eC = 0
    for i, v in ipairs(downDim) do
        local temp = {}
        for i, v in ipairs(downDim) do
            table.insert(temp, v)
        end
        temp[i] = v - 1
        if e[{ dowmP, temp }] then
            eC = eC + 1 / dowmP[i] + e[{ dowmP, temp }]
        else
            eC = eC + 1 / dowmP[i] + cal(dowmP, temp)
        end
    end
    e[{ dowmP, downDim }] = eC
    return eC
end

print(cal(p, q))

• Previous
  排序、数据结构以及分治策略的复习
• Next
  红黑树