数据类型

基本类型

  • 字符串类型
  • 整型（有符号）
  • 浮点型（有符号）
查看数据类型

type()会返回数据的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
print(type("hello world"))
int_data=520
print(type(int_data))
float_data=13.14
float_type=type(float_data)
print(float_type)

"""
输出
<class "str">
<class "int">
<class "float">
"""
类型转换

float(),int(),str()改变数据类型

1
2
int_data=int("11")
print(type(int_data),int_data)

注意点

不是所有字符串都能转整型、浮点型，如果字符串不全是数字执行时会报错

整型转浮点型会带上小数部分，例如11转成11.0

浮点型转整型会丢失小数部分，例如11.353转成11

标识符(变量名)

命名规则

  • 英文
  • 中文(不推荐使用中文)
  • 数字(不可以用在开头)
  • 下划线(_)

这四类元素

标识符区分大小写

不可使用关键字(保留字)

运算符

算术运算符
  • +加
  • -减
  • *乘
  • /除
  • //整除运算符9//2=4
  • %取余运算符9%2=1
  • **指数运算符2**3=8
赋值运算符
  • =把右边的数据赋值给左边的变量
  • +=
  • -=
  • *=
  • /=
  • %=
  • //=
  • **=幂赋值运算符,a**=c相当于a=a**c

字符串

字符串的三种定义方式

  • 单引号str='str1'

  • 双引号str="str2"

  • 三引号str="""str3"""三引号支持多行数据

如果字符串本身包含引号可以，使用其他的引号定义，也可以使用转义符**(\)**来解除引号的作用

字符串拼接

使用**+**来进行字符串拼接

注意和js不同的是：字符串不能直接通过**+**来和整型或者浮点型进行拼接，否则会报类型错误

我们可以使用字符串格式化来进行字符串类型和整型的拼接

字符串格式化

使用**%**进行占位

使用s表示将数据变成字符串放到占位的地方

1
2
3
4
tel=15151226564
money=20.365
print("我的电话号码是%s,我的钱包余额是%s"%(tel,money))
#输出:我的电话号码是15151226564,我的钱包余额是20.365

多个变量拼接使用括号括起来，用逗号分隔，按照输入顺序填入占位的地方

%s字符串占位

%d整型占位

%f浮点型占位

字符串格式化：数字精度控制
  • m控制字符串宽度，设置的宽度小于数字本身不生效
  • .n控制小数点精度，要求是数字，会进行四舍五入

%5d设置宽度为5，宽度不足会在前面补上空格

%.2设置小数点精度为2

%5.2f设置宽度为5，小数点精度为2，小数部分也计入宽度

字符串格式化：快速写法

不理会类型，不做精度控制

1
2
3
name="张三"
age=18
print(f"我的名字是{name},我的年龄是{age}")

类似js的模板字符串

字符串格式化：表达式格式化

表达式是指有明确执行结果的代码语句

1
2
str="hello world"
print("str的数据类型是%s"%(type(str)))

Input和print

print是输出

input是输入

input

input输入完成后使用回车键完成输入

input需要使用一个变量接收输入的值str=input()

input可以接收一个参数，进行输入提示

input接收输入的数据会变成字符串类型

1
2
3
str=input("验证input获取到的数据类型?\n")
print(f"数据类型是{type(str)}")
#输出：数据类型是<class 'str'>
print

print() 函数有一个名为 end 的可选参数，它决定了在输出内容后要添加什么字符作为结尾，默认情况下是换行符 \n

end参数

1
2
3
print("hello",end="")

print("world",end="")

判断语句

布尔类型

进行判断只有两个结果真或假

True表示真，False表示假

True本质上是数字记作1，False记作0

print(3+True)输出4

print(3+True-False)输出4

比较运算符
  • >
  • <
  • ==
  • !=
  • >=
  • <=
if判断语句

if 判断条件 :

[空格]条件成立的执行语句

**python中使用空格来确定语句归属，需要4个空格，一个tab就是4个空格 **

1
2
if 10>5:
    print("10确实大于5")

else

else和if同级，else是判断语句的一个分支，用来兜底，当其他分支不执行时，执行else

elif

elif和else和if同级，elif是判断语句的一个分支

循环语句

while循环语句
1
2
3
4
i=0
while i<100:
    print("hello world %d"%i)
    i+=1

while后面的是循环条件，while条件需要得到布尔类型，True是继续循环，False是停止循环

一定要设置循环终止条件，否则会无限循环

缩进的要求同if判断语句

while循环嵌套

一定要注意重置内循环的状态，否则内循环只循环一次！！！

for循环

while本质上更像循环

for本质上更像遍历和迭代

while 循环像是一个开放式的“如果……那么”语句，只要条件为真，就会重复执行。而 for 循环像是一个计数的机制，用于遍历一系列元素

1
2
for x in "hello world":
    print(x)

将hello world的字符串遍历，并赋予x临时变量

理论上for循环不可能无限循环，因为in的数据处理集不可能无限大

1
2
3
4
5
6
str="skdfkshkhkhfsadhkas"
i=0
for x in str :
    if(x=="s"):
        i+=1
print("s一共出现了%d次"%i)

for循环的变量作用域

临时变量在编程规范上，只限度在for内部

如果在for外部访问临时变量是可以访问的

在编程规范上不建议这么做

1
2
3
4
for i in range(5):
    print(i)
print(i)
#最后的i输出4
countine关键字

终止本次循环，直接进入下一次循环

在for和while中有同样的作用

在嵌套中使用，只对当前循环生效

break关键字

直接结束循环

在for和while中有同样的作用

在嵌套中使用，只对当前循环生效，记住他只是结束了当前循环，不是把当前循环代码删了

函数

提高代码复用性和开发效率

函数的定义
1
2
3
def 函数名(参数):
    函数体
    return 返回值
函数的调用
1
函数名(参数)

函数必须先定义，再使用

return返回值

返回值也是函数执行的结果，可以用来赋值

不设置返回值返回None

None是一个特殊的字面量，类型为NoneType

  • 一般用于if判断语句中，代表False
  • 也可以给一个变量赋值为None意为暂时没有具体值
return多个返回值
1
2
3
def myreturn():
    return 1,True,"hello"
x,y,z=myreturn()
函数的多种参数
  • 位置参数：根据函数的形参位置顺序，依次传递参数，顺序个数必须一致
  • 关键字传参：函数调用时，在()里使用key(形参名)=value(实参)的方式进行传参，取消了参数传递的顺序要求，可以和位置参数混用
  • 缺省参数：在函数定义时定义了参数的默认值，调用时不传该参数就使用默认值，无论定义还是调用，位置参数要在默认参数之前
  • 不定长参数：不确定调用时会传入多少个参数（不传参也可以），分为位置不定长和关键字不定长两种
1
2
3
4
5
6
7
8
9
10
11
12
13
#位置不定长
def mytest(*args):
    print(args)
mytest("hello")
mytest("hello","world",996)
#会把接收到的参数变成一个元组

#关键字不定长
def mytest(**kargs):
    print(kargs)
mytest(word1="hello")
mytest(word1="hello",Word2="world",num=996)
#会把接收到的参数变成一个字典
匿名函数

匿名函数的定义

lambda关键字，可以定义匿名函数(无名称)

有名称的函数(使用def定义的)，可以基于函数名无限次使用

使用lambda定义的匿名函数只可以临时使用一次

定义

lambda 参数:函数体(只能写一行代码，无法写多行)

1
2
3
4
5
def myprint(compute):
    print(compute(1,2))

myprint(lambda x,y:x+y)
#不用写return，直接就return了

前端OS：只能写一行，那我为啥不直接写表达式

函数作为参数传递

前端OS：这可以当做特性来显摆吗？我一直以为所有语言都能这么玩

1
2
3
4
5
def myprint(compute):
    print(compute(1,2))

def compute(a,b):
    return a+b

与普通传参不同，普通传参传的是数据，把函数作为参数传递，传递的是逻辑

函数的嵌套调用
1
2
3
4
5
6
7
8
def b():
    print(2)
    print(3)
def a():
    print(1)
    b()
    print(4)
a()

在函数a中嵌套调用b，当a中的代码执行到b的时候，会在执行完b的所有代码后，再去执行a剩下的代码

变量作用域

全局作用域和局部作用域两种

局部变量

局部变量是在函数体内部的变量

1
2
3
4
5
def a():
    num=15
    print(num)
a()
print(num) #报错num未定义

变量num的定义是在a函数内部，在外部访问报错

全局变量

在函数体内，体外都能访问到的变量

如果非要在函数内部定义一个全局变量，可以使用global关键字

1
2
3
4
5
def a():
    global num=15
    print(num)
a()
print(num) #15