抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

Python之基础语法篇

教程

发布于：2023年10月14日

次浏览

字数：3.1k 字

时长：13 分钟

Python的一些基础语法

1.占位符%（s->String字符串 d->digital数字 f->float浮点、小数点)

1
2
3
4
5
6
# 占位符:
name = 'Henrry'
age = 28
hight = 1.72345
print('我的名字是：%s,我的年龄是：%d,我目前身高保留两位小数：%.2f，保留四位小数为：%.4f' %(name,age,hight,hight))
我的名字是：Henrry,我的年龄是：28,我目前身高保留两位小数：1.72，保留四位小数为：1.7234

1.1 {} 和 format占位符：适合一个量多次占位

1
2
3
4
5
6
# 占位符:`
name = '张正'
age = 89
hight = 1.864
print('我的名字是：{0},我的年龄是：{1},我目前身高是：{2},我目前身高是：{2}'.format(name,age,hight))
我的名字是：张正,我的年龄是：89,我目前身高是：1.864,我目前身高是：1.864

1.2 f 和 ‘{}’占位符：适合有明确对应关系的占位

1
2
3
4
5
name = '张正'
age = 89
hight = 1.8
print(f'我的名字是：{name},我的年龄是：{age},我目前身高是：{hight}')
我的名字是：张正,我的年龄是：89,我目前身高是：1.8

2.转义符（换行转义\n、单双引号转义）

1
2
3
4
5
6
7
print('Today is a \nSunny Day, I\'m so "excited" too')
Today is a 
Sunny Day, I'm so "excited" too
print('D:\\soft\\Anaconda');
print('D:\soft\Anaconda');
D:\soft\Anaconda
D:\soft\Anaconda

3.骚操作生成随机验证码

1
2
3
4
5
6
7
8
9
import random
import string
print(string.digits + string.ascii_lowercase)
print('生成的随机样本：%s'%(random.sample(string.digits + string.ascii_lowercase,4)))
code = ''.join(random.sample(string.digits + string.ascii_lowercase,4)) #sample组合随机四个
print('生成的随机码为：%s'%(code))
0123456789abcdefghijklmnopqrstuvwxyz
生成的随机样本：['9', 's', '6', '0']
生成的随机码为：4tgo

4.变量的基本类型和声明

1
2
3
4
# 不可变型：字符串（str->string->'张三'） 整数（int->Integer->10） 浮点（float->float->3.14） 元组（tuple->tuple->(1,2,3,'张三')）
# 可变类型：字典（dict->dictionary-> {'name':'张三'，'age',30}）   列表（list->dictionary->[1,2,3,3.14,'大学']）
# 不可变类型：即就是无法对变量内的某个单一元素进行修改、增加、删除（指向发生变化）
# 可变类型：即就是可以对变量内的某个单一元素或者多个元素进行修改、增加、删除

4.1变量声明：字符串

1
2
3
4
5
6
7
8
9
delicious = 'delicious'
print('打印定义的字符串变量为：%s'%(delicious))
print('打印字符串在内存中的地址：%s'%(id(delicious)))    # 打印字符串在内存中的地址
print('打印字符串的长度：%d'%(len(delicious)))           # 打印字符串的长度
print('打印字符串的类型:%s'%(type(delicious)))          # 打印字符串的类型
打印定义的字符串变量为：delicious
打印字符串在内存中的地址：1532437051696
打印字符串的长度：9
打印字符串的类型:<class 'str'>

4.2变量声明：整数

1
2
3
4
5
6
7
num = 35
print('打印定义的整数变量为：%d'%(num))
print('打印整数在内存中的地址：%d'%(id(num))) # 打印字符串在内存中的地址
print('打印整数的类型:%s'%(type(num)))        # 打印字符串的类型【注意：整数int是没有len一说，数字是一个整体，并非可迭代对象】
打印定义的整数变量为：35
打印整数在内存中的地址：140730310273904
打印整数的类型:<class 'int'>

4.2变量声明：浮点-小数

1
2
3
4
5
6
7
numFloat = 35.234
print('打印定义的浮点变量为：%f'%(numFloat))
print('打印浮点数在内存中的地址：%d'%(id(numFloat))) # 打印浮点数在内存中的地址
print('打印浮点数的类型:%s'%(type(numFloat))) # 打印浮点数的类型【注意：float是没有len一说，数字是一个整体，并非可迭代对象】
打印定义的浮点变量为：35.234000
打印浮点数在内存中的地址：1532432870416
打印浮点数的类型:<class 'float'>

变量的多对多赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
# 变量的多对多赋值，主要作用在有些数据是多值返回，需要以对应数量的变量进行接收
name,myAge = 'zhangSan',28
print('多变量接值的返回：%s -- %d'%(name,myAge))

# 多对多的应用点
def myInfo():
    new_name = 'mike'
    new_age = 33
    return new_name,new_age
newName,newAge = myInfo()
print('多变量接值的返回：%s -- %d'%(newName,newAge))
多变量接值的返回：zhangSan -- 28
多变量接值的返回：mike -- 33

变量声明当中的坑-字符串和整数的共享问题

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
message_a = "goodBoy"    # 每个变量的声明都有属于自己的内存地址
print(message_a)
print(id(message_a))
message_b = "goodBoy"    # Python认为这两个一样，就指向了同一个内存地址，节省了部分的内存空间
print(message_b)
print(id(message_b))
print("================")

message_c = "good Boy"    # 每个变量的声明都有属于自己的内存地址
print(message_c)
print(id(message_c))
message_d = "good Boy"    # 上述仅仅针对简单的字符串，如果包含中文或者空格都不会被共享
print(message_d)
print(id(message_d))
print("================")

# 关于整数共享（-5到256是共享的）
num1 = 233
num2 = 233
print(id(num1),id(num2))

num3 = 257
num4 = 257
print(id(num3),id(num4))
goodBoy
1532434539440
goodBoy
1532434539440
================
good Boy
1532430726448
good Boy
1532433384816
================
140730310280240 140730310280240
1532433380400 1532433380528

5.变量的基本操作-字符串切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 只有可迭代对象才可以进行切割（字典类型除外），字符串的下表从0开始
words = "我是一个字符串"
print(words)
print(words[0])    # 基于下标取一个元素
print(words[2:4])  # 基于下标取多个元素，实际取下标为2和下标3对应的值，4终止不取值
print(words[-1])  # 基于下标最后一个元素
print(words[:4])  # 基于下标不定义开始，只定义结束，默认从下标0开始取
print(words[4:])  # 基于下标不定义开始，只定义结束，默认从下标0开始取
print(words[-3:]) # 取后三个字符
我是一个字符串
我
一个
串
我是一个
字符串
字符串

5.1不同数据类型之间的转换-整数、浮点类型转换成字符串str

1
2
3
4
5
6
7
8
9
10
11
# 针对不同的数据类型，提供不同的转换函数：str()、int()、float()
# 其他数据类型转换成字符串
date_of_birth = 20210909
new_date_of_birth = str(date_of_birth)
print(new_date_of_birth,'数据类型为：',type(new_date_of_birth))

date_of_birth_float = 20210909.999
new_date_of_birth_float = str(date_of_birth_float)
print(new_date_of_birth_float,'数据类型为：',type(new_date_of_birth_float))
20210909 数据类型为： <class 'str'>
20210909.999 数据类型为： <class 'str'>

5.2不同数据类型之间的转换-字符串转整数和浮点数

1
2
3
4
5
6
7
8
9
# int()、float()：将字符串转成整数或者浮点类型小数,字符串内非整数数字无法转成整数，字符串内非数字无法转成整数和浮点数
my_age_str = "18"
my_age_int = int(my_age_str)
print("字符串转换成整数类型:",my_age_int)

my_age_float = float(my_age_str)
print("字符串转换成整数类型,后面多一位小数:",my_age_float)
字符串转换成整数类型: 18
字符串转换成整数类型,后面多一位小数: 18.0

5.3不同数据类型之间的转换-浮点数转整数

1
2
3
4
5
# 会消除小数部分进行取整
my_age_float = 18.24
my_age_int = int(my_age_float)
print("将浮点数转整数类型:",my_age_int)
将浮点数转整数类型: 18

5.4不同数据类型之间的转换-整数转浮点数

1
2
3
4
5
# 会消除小数部分进行取整
my_age_int = 18
my_age_float = float(my_age_int)
print("将整数转浮点数类型,后面多一位小数:",my_age_float)
将整数转浮点数类型,后面多一位小数: 18.0

5.5整数和浮点的多则运算（加+ 减- 乘 *除/ 商// 余数% 次幂**）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 整数和浮点类型进行运算输出为浮点类型
number_1 = 43
number_2 = 7
print("加法：",number_1 + number_2)
print("减法：",number_1 - number_2)
print("乘法：",number_1 * number_2)
print("除法：",number_1 / number_2)
print("商："  ,number_1 //number_2)
print("余数：",number_1 % number_2)
print("幂："  ,number_2 ** 2)
加法： 50
减法： 36
乘法： 301
除法： 6.142857142857143
商： 6
余数： 1
幂： 49

5.6字符串的乘法操作及其拼接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 字符串乘法
print("字符串乘法操作：","zbzhang" * 5) #sep参数：separator
# sep参数
print("zbzhang","world","today",sep="***") # sep参数：separator


# 是有字符串和字符串才可以进行拼接，不可有整数和浮点数参与拼接，非纯字符串的拼接可先转换成字符串后拼接
result_string_1 = "I see a "
result_string_2 = "handsome boy "
result_string_3 = 10
print(result_string_1 + result_string_2 + str(result_string_3))
字符串乘法操作： zbzhangzbzhangzbzhangzbzhangzbzhang
zbzhang***world***today
I see a handsome boy 10

2.Python之内置数学函数拓展篇

2.1Python之内置数学函数

1
2
3
4
5
6
7
8
9
10
11
12
# 绝对值
print("10的绝对值为： ",abs(10))
print("-10的绝对值为：",abs(-10))
# 最大最小值
print("最大值：",max(4,5,8,1,4,6,7))
print("最小值：",min(4,5,8,1,4,6,7))
print("求和运算：",sum([4,5,8,1,4,6,7]))
10的绝对值为：  10
-10的绝对值为： 10
最大值： 8
最小值： 1
求和运算： 35

2.2Python-Math库数学函数

1
2
3
4
5
6
7
import math  # 使用math库，带库的均要进行import
print("2的3次方乘方运算",math.pow(2,3))        # 乘方运算：2的3次方
print("2.2345向上取整"  ,math.ceil(2.2345))    # 向上取整 
print("2.2345向下取整"  ,math.floor(2.2345))   # 向上取整
2的3次方乘方运算 8.0
2.2345向上取整 3
2.2345向下取整 2

3.Python之变量逻辑运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 如何将0和1转换成bool类型(False True)
result_1 = bool(0)
result_2 = bool(1)
print(result_1,result_2,type(result_1))

# and   x and y 布尔"与"  or   x or y  布尔"或"  not  (不等于的逻辑比较)
employee_man = "zhangzheng"
employee_age = 25
employee_gender = "男"

print( 18 <= employee_age <= 25 and employee_gender == "男")
print((18 <= employee_age <= 25) or (employee_man == "男"))
print(not (10 < 0))
False True <class 'bool'>
True
True
True

3.1Python成员运算符

1
2
3
4
5
6
7
8
9
10
# in：如果在指定的序列中找到值返回 True，否则返回 False。
# not in：如果在指定的序列中没有找到值返回 True，否则返回 False
a = 10
b = 20
list1 = [1, 2, 3, 4, 5 ]
if ( a in list1 ):
    print("1 - 变量 a 在给定的列表中 list 中")
else:
    print("1 - 变量 a 不在给定的列表中 list 中")
1 - 变量 a 不在给定的列表中 list 中

Python成员运算符的坑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 如果包含中文或者空格都不会被共享
bedroom = '枕头'
pillow =  '枕头'
print(bedroom,id(bedroom),pillow,id(pillow),pillow == bedroom,id(bedroom) is id(pillow))

# is与==区别：is用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。
message_c = "goodBoy"   
message_v = "goodBoy"    
print(message_c,id(message_c))
print(message_v,id(message_v))
print(message_c is message_v) 
print(message_c is not message_v)
print(message_c == message_v)
枕头 1807536016720 枕头 1807536016048 True False
goodBoy 1807529631472
goodBoy 1807529631472
True
False
True

4.Python的逻辑与循环if和else

1
2
3
4
5
6
7
8
9
10
11
12
13
# 简单的逻辑
exam_score = 60
if(exam_score < 0 or exam_score > 100):
    print("输入的值有误，请重新输入！")
else:
    if(exam_score >= 60):
        if(exam_score >= 90):
            print("成绩优秀！")
        else:
            print("成绩合格！")
    else:
        print("成绩不合格！再接再厉！")
成绩合格！

4.1Python循环语句（while、for）

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
# while 循环：在给定的判断条件为 true 时执行循环体，否则退出循环体。
# for 循环：重复执行语句
# continue 用于跳过该次循环，break 则是用于退出循环
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print(i)         # 输出双数2、4、6、8、10

i = 1
while 1:            # 循环条件为1必定成立
    print(i)         # 输出1~10
    i += 1
    if i > 10:      # 当i大于10时跳出循环
        break
# 简单for循环的构建
import time
school_name = "北京大学"
for name in school_name:
    time.sleep(2)
    print(name)
北
京
大
学

for循环伴侣：range()

1
2
3
4
5
6
print(range(10))
print(list(range(0,10,1))) # rang(10)用于返回10个0-9的元素:range(开始，截止，步长)
message_mess = input("请输入一个数字：")
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
请输入一个数字：2

循环的嵌套

1
2
3
4
5
6
7
8
9
10
11
12
my_name = 'mike'
while True:
    guess_name = input("请输入名字：")
    if(guess_name == my_name):
        print("你猜对了")
        break
    elif(guess_name == "q"):
        break
    else:
        print("你猜错了")
请输入名字：mike
你猜对了
Python之基础语法篇
https://blog.bsgun.cn/posts/48511/
本文作者
JLin
发布于
2023年10月14日
更新于
2024年1月2日
许可协议
CC BY-NC-SA 4.0
署名-非商业性使用-相同方式共享 4.0 国际。

python

语法

评论