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类,分别是 单项分支、双项分支、多项分支、巢状分支
单项分支
格式:
if
1
<
5:
print(
'条件为真输出我')
特征:
1.if条件表达式结果为真,则执行if之后所控制的代码组,如果为假,则不执行后面的代码组
2.冒号:之后下一行的内容必须缩进,否则语法错误
3.if之后的代码中如果缩进不一致,则可能缩进不一致的代码不会受到if条件表达式的控制
4.冒号:后面的代码是在条件表达式结果为真的情况下执行,所以称之为真区间 或 if区间
双项分支
格式:
if
1
<
5:
print(
'条件为真输出我')
else
:
print(
'条件为假输出我')
特征:
1.双项分支有两个区间,分别是 True控制的if区间 和 False控制的else区间
2.if区间的内容在双项分支中必须缩进,否则语法错误
多项分支
格式:
if
1
>
5:
print(
'如果1 > 5,我会被输出')
elif
9
<
8:
print(
'如果9 < 8,我会被输出')
else
:
print(
'如果以上两条都不成立,我会被输出')
特征:
1.多项分支可以添加无限个elif分支,无论如何,只会执行众多分支的其中一个
2.执行完一个分支后,分支结构就会结束,后面的分支都不会判断,也不会执行
3.多项分支的判断顺序是自上而下逐个分支进行判断的。
巢状分支
格式:
if
1
<
5:
print(
'1真的小于5哦')
if
3
<
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'