python
python语言使用强制缩进，表示语句层次以及代码块，不像C/C++/java等语言使用{}表示语句层次代码块
python的基本数据结构
变量（variable）
变量表示对象的引用，而现实世界的一切都可以看成对象，一个杯子，一支笔，一本书。。。等等都是对象，我们将其抽象化，然后用计算机语言描述，就是各种各样的类，而具体到比如我桌子上的笔，那么这支笔就是一个类实例对象，我们就可以用一个变量名来表示。假设我定义了一个笔变量，‘bi = 10’就表示我有10支笔。= 表示赋值
变量既然可以命名那我们是不是什么名字都可以取呢?不是的
变量的命名规则：
1. 变量名由：字母，数字，下划线 组成，数字不能打头
2. 变量名对字母大小写敏感，大写小写表示不同的变量
3. 变量名要避开python的关键字保留字
python中，变量就是变量没有类型，类型是指变量所引用的内存中对象的类型
int
float
bool
string
list
tuple
set
dictionary
int – 整型
float – 浮点型
a = 10
b = 10.8
c = -5
上面定义的三个对象a，c是int型对象，而b是浮点型对象
简单的说就是一切整数都是int型，一切带小数的都是浮点型，不管小数有多少位
int 和 float 两种都是数据类型，支持一些数据运算
支持的运算符有：+ - * / // ** %
上述运算符‘+ - * /’和规则数学上一样，不过 ‘/’ 运算后对象都会变为float型
并且如果运算过程中有float型变量参与，结果都会变为float型// 表示整除法，结果为整数（不是四舍五入，小数部分直接被舍弃）
** 表示冥运算 %表示取模，就是求余数
说明：如果运算过程中有float型对象参与，结果都会变为float型
a = 10
b = 6.6
c = 2
print(a + b) # a + b = 16.6
print(a - b) # a - b = 3.400...
print(a + c) # a + c = 12
print(a / c) # a / c = 5.0
print(a // c) # a // c = 5
print(a // b) # a // b = 1.0
print(a ** c) # a ** c = 100
print(a % b) # a % b = 3.400...
print(a % c) # a % c = 0
说明：’=’ 表示赋值 ‘==’表示相等
bool – 布尔型
bool型只有两种值，True 和 False ，一般是用在条件判断语句上，表示真 or 假
bool型也可以用在数据运算上，这时候True = 1，False = 0
a = 1
print(a + True)
print(a - False)
运行结果 2 ，1
string – 字符串型
字符串类型比较特殊，字符串对象一旦定义就不能再修改，但是我们还可以做一些其他的操作
python中没有char类型表示一个字符，所以在python中一个字符‘a’也是字符串
a = 'wills '
b = 'hello world'
c = ' '
len(a) # len函数用来求字符串的长度，结果是5
for i in a: # 遍历字符串a，打印其中的每一个元素
print(i，end=' ') # end=‘’表示，打印时不换行，a这个字符串的所有字符打印在一行
a1 = str.replace(a,'w','K')
print(a.title()) # capitalize()和title()函数都可以将字符串首字母大写，并且把其他字母小写
print(a.capitalize())
print(a,a1) # 结果是 wills Kills，可以看出，a并没有被修改，而是给了一个修改后的新字符串a1
print(a+b+c) # 字符串支持拼接操作，使用 + 操作符
print(a * 3) # 字符串支持复制操作，使用 * 操作符
# 字符串还支持切片下标操作，下标就是字符串从左边往右数，从0开始数,数字放在[]里
print(a[0],a[4]) # 结果‘w’和 ‘s’
print(a[0:3]，a[2:4]) # 结果 wil 和 ll
print(a[0:-1],b[-3:0]) # 结果 wills 和 无
print(b[::2],b[::-2]) # 结果 ‘hlo ol’ 和‘drw le’
print(b[::-1]) # 将字符串倒过来
# 下标切片运算时
# 当只有一个‘：’左边表示起点，右边表示终点，正数表示从左往右0开始数，负数表示从右往左-1开始数
# 当有两个‘：’，第一个‘：’左右两边规则不变,最右边数的大小表示步长，正负表示数数方向
print(sorted(a)) # 结果 ['i', 'l', 'l', 's', 'w']
# 字符串可以转换为list，字符串可以按照字母表顺序排序，不过排序后返回一个列表
x = ' hello world! ' # 所有空格都是3个
print(x)
print(x.index('o')) # 7
print(x.rindex('o')) # 12
print(x.find('h')) # 3
print(x.rfind('o')) # 12
# index和find 都表示下标索引，r表示从右边开始的某个字符
print(x.join('kk')) # 表示在‘kk’的间隔插入加一个x
print(x.strip(' ')) # 去掉x左右两边空格
print(x.lstrip(' ')) # 去掉x左边空格
print(x.rstrip(' ')) # 去掉x右边空格
print(x.ljust(20,'+')) # 以20字符长度进行左对齐，x字符不够添加 + 补足20个
print(x.rjust(20,'/')) # 右对齐，x字符不够 用 / 补齐20个
print(x.center(30,'*')) # 将x以30个字符长度居中，x字符不足以 * 补齐
print(x.split('d')) # 将x从字符‘d’这里截断为2个字符串，返回一个list
print(x.split('k')) # 如果x中中找到不到‘k’则返回整个字符串
列表（list）
列表中可以存放多个不同种类的元素，并且元素允许重复和修改
string类型中的切片index，find在list中都可以使用，并且用法相同
list中的元素是可以删除的
在python解释器中输入dir([]),即可获取list的所有内置方法
# 假设我们需要25个元素，5*5的形式
# 列表生成办法
# 1 列表生成式
list1 = [[x for x in range(5)] for _ in range(5)]
# [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
# 2 列表生成器
list2 = ((x for x in range(15))
# 列表生成器生成的是一个元组
for val in list2:
print(val,end=' ')
list1 = [2,1,3,5,4]
sorted(list1) # list1本身不变，返回一个将列表中的元素排序好的新列表【1,2,3，4,5】
print(list1) # [2,1,3,5,4]
list1.sort() # 将列表排序，但是list1本身被改变
print(list1) # [1,2,3,4,5]
del list1 # 删除整个列表
del list1[0] # 利用下标删除列表中的某个元素
del list1[1:3] # 利用删除列表中某几个元素
list1.remove(3) # 删除列表中某个已知元素
list1.append(33) # 在列表最后追加元素
list1.insert(2,11) # 插入元素，第一个参数表示插入的位置
list1 + list1 # list支持拼接，使用 + 运算符
元组（tuple）
元组的操作几乎和列表没什么差别，几个要点
a。 元组的元素是不可修改的，并且不可删除，但可用del删除整个元组
b。 元组放在（）括号里面，列表放在 [] 里面
c。 创建一个列表用 list = [ 1 ] ;而创建空元组 用 tuple =（1，）
一定要加一个，号，不然会变成整型
我们能用元组完成的就绝不要用列表，因为tuple不可修改，更安全
集合（set）
集合就像数学上的集合一样，放在大括号里，支持 交 并 差 对称差 子集 超集
集合无序，无法进行下标运算，自动去重复的元素,可以进行关系测试
set1 = {1,3,5,7,7}
set2 = {2,4,6,8}
print(set1,set3)
if 1 in set1:
print('ok') #关系测试，判断1是否在set1中
set1 - set2 # set1 与 set2 的差集
set2 - set1 # set2 与 set1 的差集
set1 & set2 # set1 与 set2 的交集
set1 | set2 # set1 与 set2 的并集
set1 ^ set2 # set1 与 set2 的对称差集字典（dictionary）
字典中的元素都是一个个的键值对，一个键值对表示一个元素，一个元素由键+值构成，键唯一不可修改，但是值可变
字典和集合一样也是放在大括号 {} 里面，可以使用键来取得对应的元素
键：可以用数字，字符串，元组（都不可修改）
可以使用del语句删除元素，len（）函数可以返回字典元素个数
dic = {'name': 'wills','age':22,'sex':'man','class':'python','age':25}
# 如果键的值定义2次，后面回复盖前面的
print(dic) # {'name': 'wills','sex':'man','class':'python','age':25}
for v in dic: # {'name': 'wills','sex':'man','class':'python','age':25}
print(v,end=' ') # 遍历后获取键值 name sex class age
del dic['age'] # 删除 键age 对应的元素
print(dic) # {'name': 'wills','sex':'man','class':'python'}
dic.get('age','没有') # 判断age是否在字典，有输出对应的值没有，返回‘没有’
print(dic.items()) # 将字典元素以(key，value)对应形式建立一个元组
print(dic.keys()) # 将字典所有key建立一个列表对象
print(dic.values()) # 将字典元素所有value建立一个列表对象
dic.update({'hi':'nihao'}) # 添加一个字典对象，注意用大括号括起来
print(dic)
分支结构if（）：条件语句
程序一般都是自上往下一次执行，但是有时候遇到多种情况都需要执行，但是又不能同时进行，这个时候就需要if条件语句
if True ：那么条件成立，if False：那么条件不成立
a = 2
b = 3
c = 1
if a>b: # if 条件语句成立的条件是a > b
a = a+b
else:
a = b
# 这里是个单次判断，如果a>b 那么 就把a+b的值赋给a;否则把b的值赋给a
if a < b:
a = b - a
elif a == b:
a = a + b
else:
a = 0
# 此处判断2次，a < b 则 a = b - a
a == b 则 a = a + b
否则 a = 0逻辑语句 and or not
and 表示 且； or 表示 或者； not 表示 非
真 and 真 —- 》真
真 and 假 —- 》假
真 or 假 —-》 真
假 or 假 —-》 假
not 真 —–》 假
not 假 —-》 真
and 和 or还具有断点功能
如果 and 前面语句为假，那么后面就不执行
如果 or 前面为真，后面也不再执行
比如 1. if 事件1 and 事件2
2. if 事件1 or 事件2
3. if not 事件1
假设 事件1： 真 事件2： 假 那么以上3个条件只有2成立
循环结构：‘for x in range（n）：’；‘while True：’
循环语句用来解决我们需要反复执行的重复内容
for 循环
for n in range(10):# 输出10个星号*
print('*',end = ' ')
for n in range(1,100,2)
print(n,end=' ')
# 输出100以内的奇数，range(1,100,2)
# 1 表示n取值的起点可以取到1，100表示终点，取不到100,2表示步长while 循环
while 循环是根据循环条件运行
while true：执行
while false：不执行
while True:
print(*)
# 死循环，不停打印*，没有停止条件
t=10
while t>0:
print(t)
t - =3
# t的值不断变小，当t<0时，while条件不成立，结束循环
a = 100
while True:
a -= 3
if a < 0:
break
# while True:恒成立，一直循环，但是a不断变小，满足if条件是，break语句可以立刻打破当前循环
定义函数（defind）
虽然python自定义了很多很多功能强大函数，但我们有时候也会自己定义函数
# 定义函数格式
def faction(*args):
...
statement
...
return ...# 我们有一个列表 l1 = [1,32,3,42,2],我想要把它打印为[00,00,00,00,00]的格式
def display(list):
for val in list:
print('%02d' % val,end=' ')
return 0
l1 = [1,32,3,42,2]
display(l1) # 输出结果为 01 32 03 42 02
定义函数时也要注意函数名，规则和变量名规则一样
如果在同一模块中定义了两个同名函数，那么后定义的那个会将前面的覆盖
函数的参数可以给一个默认值，那么不传参就表示使用默认值
类（class）
我们现实世界的万事万物都是对象，一个人，一辆车，一条鱼，一只鸟，一篇文章，这些都是对象，当我们把具有相同静态属性和动态特征的一些对象放在一起时，就构成了类，比如人类，车类，鱼类，鸟类，书籍类，当我们定义了这些类之后，我们就有了一些对应的属性概念，比如定义了人类，那么人类的静态属性就有姓名，年龄，身高，性别，。。。等静态固定的属性，除此之外，人还有相同动态特征例如跑，走，笑，哭，攻击行为，学习，但是人与人又有不同，比如一个是是学生，有考试，有成绩。另一个是婴儿，只有名字 性别 身高 哭 笑.名字，性别这些名词就是静态属性，哭笑就是动态特征那么我们可以创建2个新的子类，叫学生类，婴儿类。学生类和婴儿类都是人类的子类
那么我现在来创建一个学生类,类名首字母大写
class ClassName(object):
def __init__(self,args):
self.args = argsclass Student(object):
def __init__(self,name,age):
self.name = name
self.age = age
# age 和 name 就是学生共同的静态属性
def __str__(self):
return 'name = %s , age = %s' % (self.name,self.age)
# 设置默认返回函数，来返回名字和年龄属性，字符串形式
def study(self,course):
print('%s is studing %s ...' % (self.name,course))
def sport(self,sports):
print('%s is playing %s ...' % (self.name,sports))
stu1 = Student('king',23)
stu1.study('math')
stu2 = Student('queen',22)
stu2.sport('dance')
在上面的学生类中，我给学生定义了两种静态属性name 和 age，两种动态特征 study 和 sport,然后调用了这个类生成了两个类实例stu1和stu2,并且调用了stu1的方法study，让stu1去学习‘math’，调用了stu2的方法sport，让stu2去跳舞‘dance’
这就是面向对象的思想，让对象去做事，这里，stu1和stu2就是对象，也叫类实例，以后遇到同样的问题，调用这个学生类就好了
