函数
define 定义
语法
def 函数名(参数（可以没有）)：
code
定义一个无参的函数
函数的调用
语法 函数名（）
def game_g():
print("hello world")
game_g()
def game_d(game_name):
print("人生苦短,我用"+game_name)
game_d("python")
game_d("java")
没有参数的有返回值类型的函数
def fun():
a = 10
b = 5
c = a + b
return c
print(fun())
参数
形参(定义函数的时候括号里面的参数)
实参（调用函数时给函数时括号里面的函数）
1.形参可以有默认值，调用时该参数可以不赋值，如果赋值就会覆盖掉默认值
def people_3(name,age,sex="boy",game="lol"):
print("我的名字是{},我今年{}岁，我的性别{}，我喜欢的游戏是{}".format(name,age,sex,game))
people_3("呵呵",19)
people_3("A",18,"girl")
people_3("呵呵",19)
people_3("A",18,)
2.如果形参有默认值该形参后面的参数也必须要有默认值 （上 红色部分）
3.函数调用时实参的顺序是和形参位置一一对应的，那么就是位置参数
people_3("a",66,game = "jj",sex = "girl") # 关键字参数 位置发生变化
4.实参赋值时，如果标明参数名字=值，那么该参数就成为了关键字参数，可以不按照顺序赋值
#非固定参数 如果定义函数时，参数个数不固定时，可以定义非固定参数 def fun(name,*args,a): print("{}喜欢{}{}".format(name,args,a)) print(1,2,sep='') #fun("李狗蛋儿","dnf") fun("小邋遢","lol","王者毒药",5,"荒野行动",a = "使命召唤")
6.函数参数赋值时，如果非固定参数后还有参数，那么该参数的赋值必须用关键字参数赋值
数据类型的转换
将数据由当前类型变化为其他类型的操作就是数据类型转换。数据类型转换分为两类，分别是自动数据类型转换 和 强制数据类型转换。
自动转换(隐式转换)
自动转换时程序根据运算要求进行的转换，不许要人工干预。
1.自动类型转换不需要人工干预
2.自动类型转换大多发生在运算或者判断过程中
3.转换时向着更加精确的类型转换
强制转换（显示转换）
1.int() 强制将其他数据类型转换为整型：
(1).浮点数可以转化为整型 --> 去掉小数的部分
(2).整型 --> 额。。。整型就是整型啦，不需要再进行转换了
(3).布尔值：True --> 1 False --> 0
(4).复数：额，因为是虚拟的不存在的，所以无法进行强转
(5).字符串：只有纯整数的字符串才可以转化为整型，其他的统统都不可以，即使你大爷是“马爸爸”也不行哦
(6).那么剩下的列表、元组、字典、集合也一样很抱歉，你们长得太丑，int并不喜欢你们，所以也不会给你们进行强转
2.float() 强制将其他数据类型转化为浮点型
(1).整数转换为浮点数 --> 在整数的末尾添加“.0”即可
(2).浮点数就是浮点数啦，不需要再转换了
(3).布尔值 True --> 1.0 False --> 0.0
(4).复数还是老问题，没法进行转换
(5).字符串：纯整型或者纯浮点型字符串才可以转换，其他的统统不可以
(6).列表、元组、字典、集合不仅不招int的待见，就连float都嫌弃他们，真可怜0.0
3.bool() 将其他数据类型转换为布尔值
接下来的转化为布尔值False的情况，其他的都是True：
(1).整型的 0
(2).浮点型的 0.0（注意，这是零点零，不是我发的表情= =）
(3).布尔值的 False
(4).复数的 0j 或者是 0+0j
(5).字符串的空字符串 ‘ ’
(6).列表中的空列表 [ ]
(7).元组的空元组 ( )
(8).字典中的空字典 { }
(9).集合中的空集合 set( )
4.complex() 将其他数据类型转换为复数
(1).整型 --> 整数部分 + 0j
(2).浮点型 --> 浮点数部分 + 0j
(3).布尔值 --> True ==> 1 + 0j False ==> 0 + 0j
(4).复数：额还是老样子，复数就是复数，不需要再转换了
(5).字符串：纯整型和纯浮点型字符串可以转化为复数，只需要在最后加上“0j”即可
(6).哎，列表、元组、字典、集合依旧无法转换
5.str() 将其他数据类型转化为字符串
str在所有的强制数据类型转换中应该属于老好人一样的存在，因为所有类型的值都是可以直接转换为字符串类型，值保持不变（也可以理解为在所有数据的两侧加了字符串的引号而已）
6.list() 将其他数据转化为列表
在Python中有5种可迭代序列，可以相互转换，它们分别是：
字符串，列表，元组，字典，集合
(1).字符串：将字符串中的每个字符变成列表中的多个值（元素）
(2).元组：直接改变数据类型，括号由（）变成 [ ] 即可
(3).集合：转化为列表的时候顺序是随机的（因为集合本身就是无序的数据）
(4).字典：转换为列表的时候顺序同样是随机的，仅仅会将字典的键取出来组成列表
7.tuple() 将其他数据类型转换为元组
(1).字符串：将字符串中的每个字符变成列表中的多个值（元素）
(2).列表：直接改变数据类型，括号由 [ ] 变成（）
(3).集合：转化为元组的时候顺序是随机的（还是因为集合本身是一堆无序的数据）
(4).字典：转换为元组的时候顺序也是随机的，仅仅将字典的键取出来组成元组
8.set() 将其他数据类型转换为集合
特点：所有转化的结果顺序随机；所有重复数据只会保留一份
(1).字符串：字符串中的每个值转化为集合中的值（去重）
(2).列表：列表中的每个值转化为集合中的值（去重）
(3).字典：将字典的所有键组成集合即可
dict() 将其他类型转换为字典类型
其他类型转化为字典时需要按照指定的格式才可以转化：（列表和元组的组合可以）
#var = [['cat', '黑猫警长'], ['mouse', '一只耳'], ['next', '请看夏季']]
var = [('cat', '黑猫警长'), （'mouse', '一只耳'）, （'next', '请看夏季'）]
#转换后为 {'cat': '黑猫警长', 'mouse': '一只耳', 'next': '请看夏季'}
运算： 由一个以上的值经过变化得到新值得过程，就是运算。
运算符： 用于运算的符号，就是运算符
运算的分类：
1.算数运算
2.比较运算/关系运算
3.赋值运算
4.逻辑运算
5.位运算
6.成员运算
7.身份运算
+ 加法运算
- 减法运算
* 乘法运算
/ 除法运算
% 取余运算
// 取商运算 地板除
** 幂运算
关系运算/比较运算
< 小于运算
> 大于运算
== 等于运算
<= 小于等于运算
>= 大于等于运算
!= 不等于运算
= 普通赋值运算
+= 加法赋值运算
-= 减法赋值运算
*= 乘法赋值运算
/= 除法赋值运算
%= 取余赋值运算
//= 取商赋值运算
**= 幂赋值运算
所有运算赋值操作的格式都可以转换为[变量 = 变量 运算符 值],如：
var /= 5 相当于 var = var / 5
逻辑运算就是布尔值之间的运算，Python只有三种运算方式
1.and 逻辑与运算(有假则假；两边为真才是真)
2.or 逻辑或运算(有真则真；两边为假才是假)
3.not 逻辑非运算(真变假，假变真)
4.xor异或运算 （相同为假，不同为真）（Python中无此运算）
在二进制基础上进行的逻辑运算就是位运算。
& 按位与运算 有0为0
| 按位或运算 有1为1
～ 按位非运算 负 ---》正 去减号（-）减1 ps： -27 26
正---》负 加减号（-）加1 27 -28
^ 按位异或运算 相同为0，不同为1
<< 左移运算 相当于×2运算
>> 右移运算 相当于地板除2运算
检测一个数据是否在指定的容器(复合数据)当中
检测数据1是否在数据2中
格式：数据1 in 数据2
检测数据1是否不在数据2中
格式：数据1 not in 数据2
检测两个变量在内存中是否是同一个值
检测两个变量在内存中是不是同一个值
格式：数据1 is 数据2
检测两个变量在内存中是否不是同一个值
格式：数据1 is not 数据2
type() 测试时可是使用，开发尽量避免使用
格式：type(变量)
isinstance() 检测一个数据是否由指定的类型创建
格式：isinstance(变量，检测的类型)
循环结构可以减少源程序重复书写的工作量(代码量)，用来描述重复执行某段算法的问题，这是程序设计中最能发挥计算机特长的程序结构。
Python中循环结构分为两类，分别是 while 和 for .. in
格式1：
num1,num2 = 3,5
while num1 < num2:
print('如果条件成立，会进入循环体，我所处的这块区域，就是循环体')
num1 += 1 #控制循环条件中的变量，否则进入死循环
死循环： 死循环就是循环不会终止的循环类型，设置条件永远为True来实现，但非常占用资源
格式2：
num1,num2 = 3,5
while num1 < num2:
print('如果条件成立，会进入循环体')
num1 += 1
else:
print('条件不成立时，我会被输出')
注意： while循环中的else是在while条件表达式为假的情况下执行的代码内容
for 变量 in 容器： 用于遍历容器类的数据(字符串，列表，元组，字典，集合)
格式1：
user_list = ['小明','小红','小强','小军']
for val in user_list:
print(val)
格式2：
data = ('a','alibaba'),('b','baidu'),('c','changhong')
for k,v in data:
print(k,'======>',v)
使用格式2请注意： 要求遍历的容器必须是以下几种格式
[(),(),()] 列表中有元组
[[],[],[]] 列表中有列表
((),(),()) 元组中有元组
{(),(),()} 集合中有元组
字典的特殊使用
格式3：
data = ('a','b','c','d','e')
for v in data:
print(v)
else:
print('我else区间又来啦！')
循环结束时执行else区间的代码
break
翻译：破坏，结束
作用：在循环中break的作用是终止当前循环结构的后续所有操作，一点程序运行了break，循环也就终止了。
continue
翻译：继续
作用：在循环中continue的作用是跳过本次循环，开始下一次循环。continue执行之后本次循环的后续代码不再执行，直接进入下一次循环。
pass
翻译：忽略
作用：pass是没有任何意义的空语句，主要用来占位用，避免语法错误。
流程： 计算机执行代码的顺序，就是流程。
流程控制： 对计算机代码执行顺序的控制，就是流程控制。
流程分类： 流程控制一共分为三类，分别是 顺序结构、分支(选择)结构、循环结构。
顺序结构就是代码一种自上而下执行的结构，这是Python默认的流程。
分支(选择)结构
分支结构一共分为4类，分别是 单项分支、双项分支、多项分支、巢状分支
单项分支
格式：
if1<5:
print('条件为真输出我')
特征：
1.if条件表达式结果为真，则执行if之后所控制的代码组，如果为假，则不执行后面的代码组
2.冒号:之后下一行的内容必须缩进，否则语法错误
3.if之后的代码中如果缩进不一致，则可能缩进不一致的代码不会受到if条件表达式的控制
4.冒号:后面的代码是在条件表达式结果为真的情况下执行，所以称之为真区间 或 if区间
双项分支
格式：
if1<5:
print('条件为真输出我')
else:
print('条件为假输出我')
特征：
1.双项分支有两个区间，分别是 True控制的if区间 和 False控制的else区间
2.if区间的内容在双项分支中必须缩进，否则语法错误
多项分支
格式：
if1>5:
print('如果1 > 5，我会被输出')
elif9<8:
print('如果9 < 8，我会被输出')
else:
print('如果以上两条都不成立，我会被输出')
特征：
1.多项分支可以添加无限个elif分支，无论如何，只会执行众多分支的其中一个
2.执行完一个分支后，分支结构就会结束，后面的分支都不会判断，也不会执行
3.多项分支的判断顺序是自上而下逐个分支进行判断的。
巢状分支
格式:
if1<5:
print('1真的小于5哦')
if3<9:
print('如果3 < 9，我会被输出')
else:
print('如果上面条件不成立，我会被输出')
特征： 巢状分支是其他他分支结构的嵌套结构，无论哪个分支都可以嵌套
format格式字符串
语法： 它通过{}和:来代替%。
注意： 字符串的format函数可以接受无限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。
“映射”示例
通过位置
In [1]: '{0},{1}'.format('kzc',18)
Out[1]: 'kzc,18'
In [2]: '{},{}'.format('kzc',18)
Out[2]: 'kzc,18'
In [3]: '{1},{0},{1}'.format('kzc',18)
Out[3]: '18,kzc,18'
通过关键字参数
In [5]: '{name},{age}'.format(age=18,name='kzc')
Out[5]: 'kzc,18'
通过对象属性
class Person:
def __init__(self,name,age):
self.name,self.age = name,age
def __str__(self):
return 'This guy is {self.name},is {self.age} old'.format(self=self)
In [2]: str(Person('kzc',18))
Out[2]: 'This guy is kzc,is 18 old'
通过下标
In [7]: p=['kzc',18]
In [8]: '{0[0]},{0[1]}'.format(p)
Out[8]: 'kzc,18'
有了这些便捷的“映射”方式，我们就有了偷懒利器。基本的Python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。
它有着丰富的“格式限定符”(语法是花括号{}带冒号:)，如：
填充与对齐： 填充常跟对齐一起使用
居中 = ^
左对齐 = <
右对齐 = >
后面带宽度 = :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充，如下：
In [15]: '{:>8}'.format('189')
Out[15]: ' 189'
In [16]: '{:0>8}'.format('189')
Out[16]: '00000189'
In [17]: '{:a>8}'.format('189')
Out[17]: 'aaaaa189'
精度与类型f： 精度常跟类型f一起使用
In [44]: '{:.2f}'.format(321.33345)
Out[44]: '321.33'
其中.2表示长度为2的精度，f表示float类型。
其他类型： 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。
In [54]: '{:b}'.format(17)
Out[54]: '10001'
In [55]: '{:d}'.format(17)
Out[55]: '17'
In [56]: '{:o}'.format(17)
Out[56]: '21'
In [57]: '{:x}'.format(17)
Out[57]: '11'
逗号,还能用来做金额的千位分隔符：
In [47]: '{:,}'.format(1234567890)
Out[47]: '1,234,567,890'