目录
字面量
666
13.14
"黑马程序员"
# 通过print()语句输出各类字面量
print(666)
print(13.14)
print("黑马程序员")
# 以上都是字面量变量
变量的命名规则
1、内容限定（中文、英文、数字、下划线；不能以数字开头）
2、大小写敏感
3、不可使用关键字
name_ = "张三"
_name = "张三"
name_1 = "张三"
# 规则2：大小写敏感
Itheima = "黑马程序员"
itheima = 666
print(Itheima)
print(itheima)
# 规则3：不可使用关键字
# 错误的示例，使用了关键字：class = 1
# 错误的示例，使用了关键字：def = 1
Class = 1变量的命令规范
- 下划线命名法
- 英文字母全小写
数据类型
# 方式1： 使用print直接输出类型信息
print(type("黑马程序员"))
print(type(666))
print(type(11.345))
# <class 'str'>
# <class 'int'>
# <class 'float'>
# 方式2： 使用变量存储type()语句的结果
string_type = type("黑马程序员")
int_type = type(666)
float_type = type(11.345)
print(string_type)
print(int_type)
print(float_type)
# 方式3： 使用type()语句，查看变量中存储的数据类型信息
name = "黑马程序员"
name_type = type(name)
print(name_type)
# <class 'str'>数据类型转换
# 将数字类型转换成字符串
num_str = str(11)
print(type(num_str), num_str)
# 将浮点数类型转换成字符串
float_str = str(11.345)
print(type(float_str), float_str)
# 将字符串转换成数字
num = int("11")
print(type(num), num)
# 将字符串转换成浮点数
num2 = float("11.345")
print(type(num2), num2)
# 错误示例，想要将字符串转换成数字，必须要求字符串内的内容都是数字
# num3 = int("黑马程序员")
# print(type(num3), num3)
# 整数转浮点数
float_num = float(11)
print(type(float_num), float_num) # 11.0
# 浮点数转整数 丢失掉小数的部分
int_num = int(11.345)
print(type(int_num), int_num) # 11<class 'str'> 11
<class 'str'> 11.345
<class 'int'> 11
<class 'float'> 11.345
<class 'float'> 11.0
<class 'int'> 11运算符
# 算术运算符中的取整除
print("5 // 2等于", 5 // 2) #2
# 算数运算中取指数
print("5 ** 2等于", 5 ** 2) #25字符串的定义方式
# 单引号定义法，使用单引号进行包围
name = '黑马程序员'
print(type(name))
# 双引号定义法
name = "黑马程序员"
print(type(name))
# 三引号定义法，写法和多行注释一样
name = """
我是
黑马
程序员
"""
print(type(name))
# 在字符串内，包含双引号
name = '"黑马程序员"'
print(name)
# 在字符串中，包含单引号
name = "'零基础，学IT'"
print(name)
name = "\"黑马程序员\""
print(name)<class 'str'>
<class 'str'>
<class 'str'>
"黑马程序员"
'零基础，学IT'
"黑马程序员"input语句
"""
input()语句返回的内容还是字符串类型
"""
name = input("请告诉我你是谁？")
print("我知道了，你是:%s" % name)
# 输入数字类型
num = input("请告诉我你的银行卡密码：")
# 数据类型转换
num = int(num)
print("你的银行卡密码的类型是：", type(num))字符串格式化的方式
name = "传智播客"
set_up_year = 2006
stock_price = 19.99
# f: format
print(f"我是{name}，我成立于：{set_up_year}年，我今天的股价是：{stock_price}元")
字符串字面量之间的拼接
# 字符串字面量之间的拼接
print("学IT来黑马" + "月薪过万")
# 字符串字面量和字符串变量的拼接
name = "黑马程序员"
address = "建材城东路9号院"
tel = str(4006189090)
print("我是：" + name + "，我的地址是：" + address + "，我的电话是：" + tel)字符串精度控制
# 通过占位的形式，完成拼接
name = "黑马程序员"
message = "学IT来：%s" % name
print(message)
# %表示：我要占位
# s表示：将变量变成字符串放入占位的位置
# 通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 16781
message = "Python大数据学科，北京%s期，毕业平均工资：%s元" % (class_num, avg_salary)
print(message)
name = "传智播客"
setup_year = 2006
stock_price = 19.99
message = "%s，成立于：%d，我今天的股价是：%.2f" % (name, setup_year, stock_price)
print(message)表达式的格式化
print("1 * 1 的结果是：%d" % (1 * 1))
print(f"1 * 2的结果是：{1 * 2}")
print("字符串在Python中的类型名是：%s" % type("字符串"))Python判断语句
if判断语句
age = 10
age = int(input("请输入您的年龄："))
if age >= 18:
print("我已经成年了")
print("即将步入大学生活")
print("时间过的真快呀")
if age < 18:
print("小屁孩")if elif else 多条件判断语句
if int(input("请输入你的身高（cm）：")) < 120:
print("身高小于120cm，可以免费。")
elif int(input("请输入你的VIP等级（1-5）：")) > 3:
print("vip级别大于3，可以免费。")
elif int(input("请告诉我今天几号：")) == 1:
print("今天是1号免费日，可以免费")
else:
print("不好意思，条件都不满足，需要买票10元。")Python循环语句
While循环
i = 0
while i < 100:
print(f"小美，我喜欢你第{i}次")
i += 1获取范围在1-100的随机数字
import random
num = random.randint(1, 100)print()输出一次之后，不换行
# 内层循环的print语句，不要换行，通过\t制表符进行对齐
print(f"{j} * {i} = {j * i}\t", end='')For循环
"""
演示for循环的练习题：数一数有几个a
"""
# 统计如下字符串中，有多少个字母a
name = "itheima is a brand of itcast"
# 定义一个变量，用来统计有多少个a
count = 0
# for 循环统计
# for 临时变量 in 被统计的数据:
for x in name:
if x == "a":
count += 1
print(f"被统计的字符串中有{count}个a")Range语句
"""
演示Python中的range()语句的基本使用
range(num) 获取一个从0开始，到num结束的数字序列(不含num本身)
"""
# range语法1 range(num)
# for x in range(10):
# print(x)
# range 语法2 range(num1, num2)
# for x in range(5, 10):
# # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
# print(x)
# range 语法3 range(num1, num2, step)
# for x in range(5, 10, 2):
# # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间的间隔是2
# print(x)
# for x in range(10):
# print("送玫瑰花")
count = 0
for x in range(1,100):
if x % 2 == 0:
count += 1
print(f"1到100（不含100本身）范围内，有{count}个偶数")循环中断
# 演示循环中断语句 continue
for i in range(1, 6):
print("语句1")
continue # continue关键字用于：中断本次循环，直接进入下一次循环
print("语句2")
# 最后输出结果为五个 语句一
# 演示continue的嵌套应用
for i in range(1, 6):
print("语句1")
for j in range(1, 6):
print("语句2")
continue
print("语句3")
print("语句4")
# 演示循环中断语句 break
for i in range(1, 101):
print("语句1")
break
print("语句2")
print("语句3")
# 输出 语句1，语句3
# 演示break的嵌套应用
for i in range(1, 6):
print("语句1")
for j in range(1, 6):
print("语句2")
break
print("语句3")
print("语句4")
# 语句1、2、4输出5次函数
函数：组织好的，可重复使用的，用来实现特定功能的代码段
str1 = "张三李四"
def my_len(data):
count = 0
for i in data:
count += 1
print(f"字符串依次为{i}")
print(f"字符串{data}的长度是{count}")
my_len(str1)字符串依次为张
字符串依次为三
字符串依次为李
字符串依次为四
字符串张三李四的长度是4
函数定义
def say_hi():
print("Hi 我是黑马程序员，学Python来黑马")
# 调用函数，让定义的函数开始工作
say_hi()list列表的循环
def list_while_func():
"""
使用while循环遍历列表的演示函数
:return: None
"""
my_list = ["传智教育", "黑马程序员", "Python"]
# 循环控制变量通过下标索引来控制，默认0
# 每一次循环将下标索引变量+1
# 循环条件：下标索引变量 < 列表的元素数量
# 定义一个变量用来标记列表的下标
index = 0 # 初始值为0
while index < len(my_list):
# 通过index变量取出对应下标的元素
element = my_list[index]
print(f"列表的元素：{element}")
# 至关重要 将循环变量（index）每一次循环都+1
index += 1
def list_for_func():
"""
使用for循环遍历列表的演示函数
:return: None
"""
my_list = [1, 2, 3, 4, 5]
# for 临时变量 in 数据容器:
for element in my_list:
print(f"列表的元素有：{element}")
# list_while_func()
list_for_func()函数的参数
# 定义2数相加的函数，通过参数接收被计算的2个数字
def add(x, y, z):
result = x + y + z
print(f"{x} + {y} + {z}的计算结果是：{result}")
# 调用函数，传入被计算的2个数字
add(5, 6, 7)函数返回值定义语法
def add(a, b):
result = a + b
# 通过返回值，将相加的结果返回给调用者
return result
# 返回结果后，还想输出一句话; 但是其实最终返回不了，return后面的语句不会再执行了
print("我完事了")
# 函数的返回值，可以通过变量去接收
r = add(5, 6)
print(r)None特殊字面量
无return语句的函数返回值
def say_hi():
print("你好呀")
result = say_hi()
print(f"无返回值函数，返回的内容是：{result}") #None
print(f"无返回值函数，返回的内容类型是：{type(result)}") #<class 'NoneType'>主动返回None的函数
def say_hi2():
print("你好呀")
return None
result = say_hi2()
print(f"无返回值函数，返回的内容是：{result}") #None
print(f"无返回值函数，返回的内容类型是：{type(result)}") #<class 'NoneType'>None用于if判断
def check_age(age):
if age > 18:
return "SUCCESS"
else:
return None
result = check_age(16)
# if result == None
if not result:
# 进入if表示result是None值 也就是False
print("未成年，不可以进入")变量的作用域
演示局部变量
def test_a():
num = 100
print(num)
test_a()
# 出了函数体，局部变量就无法使用了
print(num) #undefined演示全局变量
num = 200
def test_a():
print(f"test_a: {num}")
def test_b():
print(f"test_b: {num}")
test_a()
test_b()
print(num)函数内修改全局变量
num = 200
def test_a():
print(f"test_a: {num}")
def test_b():
num = 500 # 局部变量
print(f"test_b: {num}")
test_a()
test_b()
print(num) #全局变量仍然为200global关键字，在函数内声明变量为全局变量
num = 200
def test_a():
print(f"test_a: {num}")
def test_b():
global num # 设置内部定义的变量为全局变量
num = 500
print(f"test_b: {num}")
test_a()
test_b()
print(num) #500函数进阶
函数的多返回值
# 演示使用多个变量，接收多个返回值
def test_return():
return 1, "hello", True
x, y, z = test_return()
print(x)
print(y)
print(z)函数参数的多种使用形式
1、位置参数：调用函数时根据函数定义的参数位置来传递参数(传递的参数和定义的参数顺序及个数必须一致)
2、关键字参数：函数调用时通过“键=值”形式传递参数，可以让函数更加清晰、容易使用，清除了参数的顺序需求；可以和位置参数混用，位置参数必须在前，且匹配参数顺序
3、缺省参数(默认参数)
4、不定长参数：
①位置传递：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型
② 关键字传递：参数是“键=值”形式的情况下，所有的“键=值”都会被kwargs接受，同时根据传入值组成字典
def user_info(name, age, gender):
print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
# 位置参数 - 默认使用形式
user_info('小明', 20, '男')
# 关键字参数
user_info(name='小王', age=11, gender='女')
user_info(age=10, gender='女', name='潇潇') # 可以不按照参数的定义顺序传参
user_info('甜甜', gender='女', age=9)
# 缺省参数（默认值） 设置默认值时必须后面的已经设置好默认值才可以
def user_info(name, age, gender='男'):
print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
user_info('小网', 13)
user_info('小天', 13, '男')
user_info('小名', 15, '女')
# 不定长 - 位置不定长, *号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
print(f"args参数的类型是：{type(args)}，内容是:{args}")
user_info(1, 2, 3, '小明', '男孩')
# args参数的类型是：<class 'tuple'>，内容是:(1, 2, 3, '小明', '男孩')
# 不定长 - 关键字不定长, **号 key-word
def user_info(**kwargs):
print(f"args参数的类型是：{type(kwargs)}，内容是:{kwargs}")
user_info(name='小王', age=11, gender='男孩')
# args参数的类型是：<class 'dict'>，内容是:{'name': '小王', 'age': 11, 'gender': '男孩'}函数作为参数传递
定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
result = compute(1, 2) # 确定compute是函数
print(f"compute参数的类型是:{type(compute)}") # <class 'function'>
print(f"计算结果：{result}")
# 定义一个函数，准备作为参数传入另一个函数
def compute(x, y):
return x + y
# 调用，并传入函数
test_func(compute)匿名函数lambda
def test_func(function):
result = function(1, 2)
print(f"结果是:{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入
def add(x, y):
return x + y
test_func(add)
# 匿名函数 lambda 传入参数：函数体（一行代码）
test_func(lambda x, y: x + y)
扫一扫
1253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
