KWAN的解忧杂货铺

# 一.基础介绍

# 1.注意点

  1. 方法要在 main 函数上面定义,脚本语言和 js 一样的,按顺序执行
  2. tab 和空格的混用,缩进比较敏感
  3. python 和 go 一样,不需要括号,简洁
  4. 不需要尾部的分号
  5. java 中的大括号在 python 中是冒号:,在 go 中是大括号不变{}
  6. python 中的注释是用#,不是//,注意区别
  7. bool 类型为 True 和 False
  8. python 中没有 a++操作但是可以 a+=1

# 2.单行注释

使用#号进行单行注释,并且井号后面空一格

# 注释
1

# 3.多行注释

文档注释

"""
这是文档注释
"""
1
2
3

# 4.输入字符

输入的都是字符串类型,如果想要数字,需要使用 int 转换

guess_num = int(input("输入你要猜测的数字："))
1

# 二.入门语法

# 1.变量

# 定义一个变量：钱包, 用来存储余额数字
money = 5
# 查看一下，钱包还剩余多少钱
print(money)
1
2
3
4

# 2.字面量

print(666)
print(13.14)
print("黑马程序员")
1
2
3

# 3.type

使用 type 判断类型

# 方式1： 使用print直接输出类型信息
print(type("黑马程序员"))
print(type(666))
print(type(11.345))
1
2
3
4

# 4.类型转换

  • str
  • int
  • float
# 将数字类型转换成字符串
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)
# 浮点数转整数
int_num = int(11.345)
print(type(int_num), int_num)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 5.标识符

  • 内容限定，限定只能使用：中文、英文、数字、下划线，注意：不能以数字开头
  • 大小写敏感
  • 不可使用关键字
# 规则1：内容限定，限定只能使用：中文、英文、数字、下划线，注意：不能以数字开头
# 错误的代码示范：1_name = "张三"
# 错误的代码示范：name_! = "张三"
name_ = "张三"
_name = "张三"
name_1 = "张三"


# 规则2：大小写敏感
Itheima = "黑马程序员"
itheima = 666
print(Itheima)
print(itheima)

# 规则3：不可使用关键字
# 错误的示例，使用了关键字：class = 1
# 错误的示例，使用了关键字：def = 1
Class = 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 6.不换行

在 Python 中，如果要在 print 语句中输出内容时不换行，可以在 print 语句的末尾加上 end=''，表示输出结束后不换行。例如：

print('Hello,', end='')
print('world!')
1
2

这段代码的输出结果为：

Hello,world!
1

如果想要输出多个内容，可以使用逗号分隔。例如：

print('Hello,', 'world!', end='')
print('Python')
1
2

这段代码的输出结果为：

Hello, world!Python
1

# 7.Python 制表符

在 Python 中，制表符可以用 \t 表示。在字符串中使用 \t 表示一个制表符，可以将字符串中的内容按照制表符的宽度进行对齐。例如：

print('Name\tAge\tCity')
print('Tom\t18\tNew York')
print('Jerry\t20\tLos Angeles')
1
2
3

输出结果为：

Name    Age     City
Tom     18      New York
Jerry   20      Los Angeles
1
2
3

在这个例子中，我们使用 \t 将表格中的各个单元格进行了对齐。需要注意的是，制表符的宽度是固定的，通常为 8 个空格宽度，但在不同的终端或编辑器中，制表符的宽度可能会有所不同。

# 8.布尔类型

# 定义变量存储布尔类型的数据
bool_1 = True
print(f"bool_1={bool_1}")

bool_2 = False
print(f"bool_1变量的内容是：{bool_1}, 类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2}, 类型是：{type(bool_2)}")
1
2
3
4
5
6
7

# 三.字符串

# 1.字符串拼接

# 字符串字面量之间的拼接
print("学IT来黑马" + "月薪过万")
# 字符串字面量和字符串变量的拼接
name = "黑马程序员"
address = "建材城东路9号院"
tel = 4006189090

# 不报错
print("我是：" + name + "，我的地址是：" + address + "，我的电话是：" + str(tel))

# 报错
print("我是：" + name + "，我的地址是：" + address + "，我的电话是：" + tel)
1
2
3
4
5
6
7
8
9
10
11
12

# 2.字符串格式化

  • 占位符
    • %s 字符串
    • %d 整数
    • %f 浮点数
  • 使用 f”包裹字符串”
# 通过占位的形式，完成拼接
name = "黑马程序员"
message = "学IT来：%s" % name
print(message)

# 通过占位的形式，完成数字和字符串的拼接
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，我今天的股价是：%f" % (name, setup_year, stock_price)
print(message)

num1 = 11
num2 = 11.345
print("数字11宽度限制5，结果是：%5d" % num1)
print("数字11宽度限制1，结果是：%1d" % num1)
print("数字11.345宽度限制7，小数精度2，结果是：%7.2f" % num2)
print("数字11.345不限制，小数精度2，结果是：%.2f" % num2)


bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{bool_1}, 类型是：{type(bool_1)}")
print(f"bool_2变量的内容是：{bool_2}, 类型是：{type(bool_2)}")
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

# 3.单双引号

在 Python 中，单引号和双引号都可以用来表示字符串。这两种引号的作用是相同的，都可以用来创建字符串。

通常情况下，使用单引号或双引号都可以，但是在某些情况下，你可能需要使用其中一种引号来避免错误。

例如，如果你需要在字符串中包含单引号，那么你可以使用双引号来创建字符串，以避免引号冲突。同样地，如果你需要在字符串中包含双引号，那么你可以使用单引号来创建字符串。

下面是一个示例代码：

string1 = "I'm using double quotes to create this string."
string2 = 'I am using single quotes to create this string, and it contains a "double quote" character.'
1
2

在这个代码中，string1使用双引号创建字符串，并包含一个单引号字符。string2使用单引号创建字符串，并包含一个双引号字符。

总之，使用哪种引号来创建字符串是个人偏好问题，但在一些特定情况下，需要使用一种引号来避免引号冲突。

# 4.字符串的打印

print(f"message = {name}，成立于：{setup_year}，我今天的股价是：{stock_price}")
1

# 四.判断语句

# 1.if 语句

age = 10

if age >= 18:
    print("我已经成年了")
    print("即将步入大学生活")

print("时间过的真快呀")
1
2
3
4
5
6
7

# 2.else 语句

age = int(input("请输入你的年龄："))
if age >= 18:
    print("您已成年，需要买票10元。")
else:
    print("您未成年，可以免费游玩。")
1
2
3
4
5

# 3.elif 语句


# 通过if判断，可以使用多条件判断的语法
# 第一个条件就是if
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元。")
1
2
3
4
5
6
7
8
9
10
11

# 五.循环语句

# 1.while

i = 0
while i < 100:
    print("小美，我喜欢你")
    i += 1
1
2
3
4

# 2.九九乘法表

# 定义外层循环的控制变量
i = 1
while i <= 9:
    # 定义内层循环的控制变量
    j = 1
    while j <= i:
        # 内层循环的print语句，不要换行，通过\t制表符进行对齐
        print(f"{j} * {i} = {j * i}\t", end='')
        j += 1
    i += 1
    print()  # print空内容，就是输出一个换行
1
2
3
4
5
6
7
8
9
10
11

# 3.for 循环

# 统计如下字符串中，有多少个字母a
# name = "itheima is a brand of itcast"
name = [1, 2, 3, 4, 5]
# 定义一个变量，用来统计有多少个a
count = 0
# for 循环统计
# for 临时变量 in 被统计的数据:
for x in name:
    if x == 3:
        count += 1
print(f"被统计的字符串中有{count}个a")
1
2
3
4
5
6
7
8
9
10
11

# 4.range

# range 语法3 range(num1, num2, step)
for x in range(5, 10, 3):
    # 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间的间隔是2
    print(x)
1
2
3
4

# 5.变量作用域

i = 0
for i in range(5):
    print(i)
print(i+1)
1
2
3
4

输出:

0 1 2 3 4 5

# 6.continue

import random
num = random.randint(1, 10)
# 演示循环中断语句 continue
 for i in range(1, 6):
     print("语句1")
     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")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 7.break


# 演示循环中断语句 break
 for i in range(1, 101):
     print("语句1")
     break
     print("语句2")

 print("语句3")


# 演示break的嵌套应用
for i in range(1, 6):
    print("语句1")
    for j in range(1, 6):
        print("语句2")
        break
        print("语句3")
    print("语句4")
print(num)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 8.内层循环结束外层循环

在 Python 中，可以使用break语句来结束循环。如果你想在内层循环结束外层循环，你可以在内层循环中使用break语句，并在外层循环中使用else语句来检查内层循环是否已经被break中断了。

下面是一个示例代码：

for i in range(10):
    for j in range(10):
        if j == 5:
            break
    else:
        continue
    break
1
2
3
4
5
6
7

在这个代码中，外层循环是一个简单的for循环，它迭代 10 次。内层循环也是一个简单的for循环，它也迭代 10 次。但是，当内层循环的j变量等于 5 时，内层循环会用break语句中止。当内层循环被中止时，else语句不会执行，因此外层循环会继续执行。但是，当外层循环执行到break语句时，它也会中止，从而结束整个循环。这样，你就可以在内层循环结束时结束外层循环了。

# 9.nonlocal使用

下面是一个使用 nonlocal 的简单示例，展示了如何在嵌套函数中修改外部函数的局部变量：

def outer():
    counter = 0

    def inner():
        nonlocal counter  # 声明counter为非局部变量
        counter += 1

    for _ in range(5):
        inner()
    print(counter)  # 输出将是5

outer()
1
2
3
4
5
6
7
8
9
10
11
12

在这个例子中，inner 函数通过 nonlocal 关键字声明了 counter 变量，使其能够访问并修改 outer 函数中的 counter 变量。

与global的区别:

global 关键字用于在函数内部声明一个变量为全局变量，即它指向的是全局作用域中的变量。而 nonlocal 用于声明一个变量为非局部变量，即它指向的是最近的非全局作用域中的变量。简而言之，global 用于全局作用域，而 nonlocal 用于局部作用域。

上次更新: 10/29/2024, 10:27:50 AM

02-Python函数 →