python入门

关于pycharm

复制代码

ctrl+D

入门语法

print语句

print语句可以打印多个量，中间用逗号隔开

输入不换行

默认print语句输入会自动换行

在print语句中加入end=''即可实现不换行

xxxxxxxxxx
print("不换",end='')
print("行",end='')

制表符\t

在字符串中有一个特殊符号\t，效果等同于在键盘上按下tab键

他可以让我们多行字符串进行对齐

换行

xxxxxxxxxx
print("换\n行")

字面量

数字（Number）

整数（int）

浮点数（float）

复数（plexcoml）

布尔（bool）表达现实生活中的逻辑，即真和假，True表示真，False表示假，True本质上就是一个数字记作1，False记作0

字符串（String）

又称文本，是由任意数字的字符如中文，英文，各类符号，数字等组成

书写格式：

xxxxxxxxxx
print("daima")

字符串的三种定义方式

单引号定义

双引号定义

三引号定义（和多行注释写法一样，但是若写成多行字符串，最后输出也只会变成一行）

单引号定义法，内可含双引号

xxxxxxxxxx
name_1 = ' "biancheng" '

print(name_1)

双引号定义法，内可含单引号

xxxxxxxxxx
name_1 = " 'biancheng' "

print(name_1)

用\消除引号的引用效果

xxxxxxxxxx
name_1 = "\"biancheng\""

print(name_1)

输出效果：

"biancheng"

字符串的拼接

直接使用+进行拼接

数字无法和字符串进行拼接

字符串格式化

方法一：

xxxxxxxxxx
a = 'python字符串的拼接'
b = '我要学习的内容是： %s ' % a

print(b)

字符串的格式化类似于上面的内容

%表示我要占位

s表示将变量变成字符串放入站位的位置

xxxxxxxxxx
a = [1,2,3,4]
b = 16
c = 'A = %s 集合A的子集的个数为： %s' % (a , b)

print(c)

多个变量占位，要用括号括起来并且用逗号间隔，要按照顺序书写

格式符号

%s 把变量转换成字符串，放入占位位置

%d 把变量转换成整数，放入占位位置

%f 把变量转换成浮点型，放入占位位置

方法二：

f 作为标记符{变量}

xxxxxxxxxx
number_1 = 10
number_2 = 4.26
topic = 'python_study'

print(f'topic:{topic} number_1:{number_1} number_2:{number_2}')

适合对精度没有控制的时候快速格式化

这种格式化不会理会数据类型，不做精度控制

字符串格式化的精度

我们可以用辅助符号m.n来控制精度

m 控制宽度，要求是数字（很少使用），设置的宽度小于数字自身不生效

xxxxxxxxxx
number_1 = 1012345

print('%10d' % number_1)

.n 控制小数点精度，要求是数字，会进行小数的四舍五入

xxxxxxxxxx
number_2 = 5.12345

print('%.2f' % number_2)

输出结果：

5.12

注意：控制精度时宽度小于本身时不生效！！！

表达式的格式化

可以用上面的任何方法去进行格式化表达式

例：

xxxxxxxxxx
print('1+1的结果是：%d' % (1+1))

print(f'20 * 10的结果是：{20 * 10}')

print('10的数据类型是：%s' % type(10))

输出：

1+1的结果是：2 20 * 10的结果是：200 10的数据类型是：<class 'int'>

列表（List）

有序可变序列

元素（Tuple）

有序不可变序列

集合（Set）

无序不重复集合

字典（Dictionary）

无需Key-Value集合

注释

单行注释

书写格式

xxxxxxxxxx
# 输出字符串Hello Python
print("Hello Python")

注：#和注释内容中间最好空一个格

多行注释

书写格式

xxxxxxxxxx
"""
输出字符串
Hello Python
"""
print("Hello Python")

变量

在程序运行时能够储存计算结果或者能表示值的概念

变量的格式

变量名称 = 变量的值

（赋值）

xxxxxxxxxx
a = 10
b = 20

print输出语句

xxxxxxxxxx
print(内容1,内容2,内容3,.......)

变量的运算

xxxxxxxxxx
money = 50
money = money - 10

pycharm复制快捷键：ctrl+D

数据类型

type()使用方法

1、可以在print语句中直接输出类型信息

xxxxxxxxxx
print(type('biancheng'))
print(type(111))
print(type(2.4))

输出结果

<class 'str'> <class 'int'> <class 'float'>

2、用变量存储type()的结果（返回值）

xxxxxxxxxx
a = type('biancheng')
print(a)

（举一例剩下同理）

3、用type语句查看变量中储存的数据类型

xxxxxxxxxx
b = 10
c = type(b)
print(c)

（举一例剩下同理）

数据类型转换

语法：

int（变量名）转换成整数

float（变量名）转换成浮点数

str（变量名）转换成字符串

xxxxxxxxxx
a = 10
print(type(a))
a = str(a)
print(type(a))

注：任何都可以转换成字符串，但是字符串不能转换成数字

标识符

标识符命名中只允许出现

中文

英文

数字

下划线(_)

这四类元素

其余各类元素都不允许（不推荐使用中文，数字不可使用在开头）

不得占用关键字

变量命名规范：

①见名知意思

②下划线命名法

③英文字母全小写

运算符

+加法

-减法

*乘法

/除法

//取整除

%取余

**指数

xxxxxxxxxx
print(1+1)
print(1-1)
print(1*1)
print(1/1)
print(30//8)
print(30%8)
print(2**4)

输出结果：

2 0 1 1.0 3 6 16

以上的运算符后面加上=相当于这个运算的赋值运算符

数据输入

input()语句

例：（获取姓名）

xxxxxxxxxx
print('姓名')

name = input()

print(f'你的名字是：{name}')

简化代码，提示信息可以直接写入input语句中

xxxxxxxxxx
name = input('姓名')

print(f'你的名字是：{name}')

input无论写入什么语句都会写成字符串

用数据转换

xxxxxxxxxx
number = input("你的电脑密码")
number = int(number)

print(type(number))

判断语句

布尔类型

进行判断，只有两个结果，是，否

True表示真

False表示假

比较运算符

== 判断内容是否相等

!= 判断内容是否不相等

＞判断左侧内容是否大于右侧内容

＜判断右侧内容是否大于左侧内容

＞= 判断左侧内容是否大于等于右侧内容

＜= 判断右侧内容是否大于等于左侧内容

（满足为True，不满足为False）

if判断语句

if 要判断的条件 :

条件成立时 要做的事情

xxxxxxxxxx
age = input('你今年几岁了')
age = int(age)
if age >= 18:
    print("你成年了")

当结果为True时代码会被执行，当结果为False时代码不会被执行

if else判断语句

if 要判断的条件 :

条件成立时 要做的事情

else:

但条件不成立时 要做的事情

xxxxxxxxxx
age = input('你今年几岁了')
age = int(age)
if age >= 18:
    print("你成年了")
else:
    print("你还是未成年")

if elif else判断语句

if 条件1 :

条件成立时 要做的事情

elif 条件2：

条件成立时 要做的事情

elif条件n：

条件成立时 要做的事情

else:

但条件不成立时 要做的事情

xxxxxxxxxx
age = input('你今年几岁了')
age = int(age)
if age >= 18:
    print("你成年了")
elif age <= 16:
    print("你未满16周岁")
elif age <= 18:
    print("你未满18周岁")
else:
    print("你还是未成年")

判断顺序从上到下，若1满足就不会进入2

也可以不写else就进行if判断

xxxxxxxxxx
age = input('你今年几岁了')
age = int(age)
if age >= 18:
    print("你成年了")
elif age <= 16:
    print("你未满16周岁")
elif age <= 18:
    print("你未满18周岁")

注意：空格缩进不可以省略

判断语句的嵌套

判断有两层，当外层满足if条件时才会执行内层if判断

当外层if不满足，直接执行外层else

嵌套原理逐层递进

具体层级在于空格缩进

通过空格缩进来决定具体层级关系

xxxxxxxxxx
print("请进行基本信息填写")

if int(input("请输入你的年龄（用阿拉伯数字输入）")) > 18:
    print("您已被默认识别为德强学校的老师")
    if int(input("请输入你的会员等级")) >= 3:
        print("您已满三级下面进行礼物选择")
        give = input("请输入你想选择的礼物")
        print("您所选的礼物将在三个工作日内给您邮寄")
    else:
        print("您的会员等级不满三级无法给你礼物，请加速提升等级")
else:
    print("您的年龄未满十八周")
    school_minor = input("请输入你的学校")
    if school_minor == "德强":
        print("欢迎你来到德强")
    else:
        print("非德强学子无法录入系统")

循环语句

while循环的基础语法

语法：while 条件：

执行内容

满足条件时则一直循环，不满足条件则结束循环

案例：

猜数字

xxxxxxxxxx
import random
num = random.randint(1,100)

b = True

while b:
    a = int(input("请输入你猜的数字"))
    if a == num:
        print("你猜对了！")
        b = False
    elif a < num:
        print("你猜的数字小了")
    else:
        print("你猜的数字大了")

while循环嵌套

同判断语句的嵌套一样，循环语句的嵌套要注意空格缩进

·基于空格缩进来决定层次关系

注意：避免出现无限嵌套

循环嵌套案例：99乘法表

xxxxxxxxxx
a = 1

while a <= 9:
    b = 1
    while b <= a:
        if b < a:
            print(f"{b}*{a}={a*b}\t",end='')
            b += 1
        else:
            print(f"{b}*{a}={a*b}\t")
            b += 1
    a += 1

代码优化：

xxxxxxxxxx
a = 1

while a <= 9:
    b = 1
    while b <= a:
        print(f"{b}*{a}={a*b}\t",end='')
        b += 1
    a += 1
    # 换行
    print()

输出一个空，就相当于换行

for循环语句

for 临时变量 in 待处理数据集：

循环满足条件时执行的代码

for循环无法定义循环条件，只能从被处理的数据集中，依次取出内容进行处理

xxxxxxxxxx
a = '123423426456734573567'

c = 0
for b in a:
    if b == "7":
        c += 1

print(f"一共有{c}个7")

注意数据类型！！！

range语句

for循环语句本质上是遍历：序列类型

尽管除字符串外，其他的类型目前还没有学习到，我们可以通过range语句获得一个数字序列

语法1：

range(num)

获取从0开始到num结束的数字序列，不含num本身！

num = 5 [0.1,2,3.4]

语法2：

range(num1,num2)

获得一个从num1到num2结束的数字，包含num1但不包含num2，且为整数

语法3：

range(num1,num2,step)

获得一个从num1到num2结束的数字，包含num1但不包含num2，且为整数

数字之间的步长，以step为准(默认为1)

变量作用域

临时变量在编陈规范上，作用范围（作用域），只限定在for循环内部

若果在for循环外部访问临时变量：

·实际上是可以访问到的

·在编程规范上，是不允许的，不建议这么做的

如果在for循环外部访问临时变量我们应在for循环前面定义临时变量

for循环的嵌套

同样也是根据句空格缩进实现for循环

xxxxxxxxxx
i = 1
for i in range(101):
    print(f"这是我向小美表白的第{i}天")
    for j in range(1,11):
        print(f"这是我今天送的第{j}朵玫瑰")
    print(f"第{i}天表白结束")
print(f"表白第{i}天，表白成功")

互相嵌套模式

xxxxxxxxxx
i = 1
while i <= 100:
    for j in range(1,11):
        print(f"第{j}朵玫瑰花")
    print(f"表白第{i}天")
    i += 1
print(f"表白{i - 1}天，表白成功")

用for循环输出99乘法表

xxxxxxxxxx
i = 1
for i in range(1,10):
    for j in range(1,i + 1):
        print(f"{i}*{j}={i * j}\t",end='')
    print()

循环中断：break和continue

应用场景：

·暂时跳过某次循环，直接进行下一次

·提前退出循环，不再继续

continue

用于中断本次循环，直接进入下一次循环

可以用于for和while循环，效果一致

示例代码：

xxxxxxxxxx
for i in range(10):
    print("a")
    continue
    print(f'{i}')

上面代码中的print(f'{i}')不会被执行而会直接跳过

循环嵌套中，continue只对当前使用循环起作用

break

用于直接结束循环

可以用于for和while循环，效果一致

示例代码：

xxxxxxxxxx
for i in range(10):
    print("a")
    break
    print(f'{i}')
print("结束")

遇到break次次循环直接结束，不再进行循环

例如上面不再执行print(f'{i}')，也不会再进行循环，直接执行print("结束")

循环嵌套中，break只对当前使用循环起作用

循环嵌套练习案例：员工发工资

方案1：

xxxxxxxxxx
num = 1
i = 1
yuan = 10000

for i in range(1,21):
    import random
    num = random.randint(1,10)
    if yuan == 0:
        print("工资发完了")
        break
    elif num < 5:
        print(f"员工{i}，绩效分{num}，低于五分，不发工资，下一位")
    else:
        yuan -= 1000
        print(f"员工{i}发放工资1000元，账户余余额：{yuan}")

方案2：

xxxxxxxxxx
num = 1
i = 1
yuan = 10000

for i in range(1,21):
    import random
    num = random.randint(1,10)

    if num < 5:
        print(f"员工{i}，绩效分{num}，低于五分，不发工资，下一位")
        continue
        
    if yuan >= 1000:
        yuan -= 1000
        print(f"员工{i}发放工资1000元，账户余余额：{yuan}")
    else:
        print("工资发完了")
        break

函数

函数的基础定义语法

xxxxxxxxxx
def 函数名(传入参数):
    函数体
    return 返回值

函数的调用：

函数名（参数）

参数如果不需要可以省略

返回值如果不需要可以省略

函数必须定义之后使用

传入参数

传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据

传入参数案例：

xxxxxxxxxx
def add (x , y):
    resule = x + y
    print(f"{x}+{y}={resule}")
    return

add(1 , 5)

函数定义中的参数称为形式参数

函数调用中的参数称为实际参数

函数的参数数量不限，使用逗号分隔开

传入参数的时候，要和形式参数一一对应，逗号隔开

函数返回值

return

完成功能之后结果回返回给函数调用者

xxxxxxxxxx
def add (x , y):
    resule = x + y
    return resule

print(add(1,2))

函数遇到return就结束了，再写什么也不会执行了

none

无返回值的函数，就实际上返回了none这个字面量

不写就为返回none

不写：

函数说明文档

函数是纯代码语言，想要理解其含义，就要一行行的去阅读理解代码，效率比较低

我们可以给函数添加说明文档，辅助理解函数的作用

语法如下：

xxxxxxxxxx
'''
函数说明
:param x:形参x说明
:param y:形参y说明
:return:返回值说明
'''

在pycharm中写出‘’‘按回车键即可自动补全

函数的嵌套调用

在一个函数已调用了另外一个函数叫做函数的嵌套

执行顺序，依照顺序向下，嵌套函数执行完才会执行原函数

xxxxxxxxxx
def a():
    print('2')

def b():
    print('1')
    a()
    print('3')

b()

局部变量

局部变量的作用域作用在函数内部，只在函数内部生效

函数调用完之后，则会立即销毁局部变量

在函数外访问的时候则该变量会立即报错，无法访问

如果我们在函数外部设定，一个同函数内部变量名称相同的变量，则在内部的变量不会影响到函数外部的变量

xxxxxxxxxx
num = 200
def a():
    num = 100
    print(num)

print(num)
        
a()

全局变量

在代码中都能生成的变量，在函数外定义即可

局部变量就是局部变量和全局变量没有任何关系

global

在函数中加上global 变量名，使在函数内定义的变量等同于全局变量

xxxxxxxxxx
num = 200
def a():
    global num
    num = 100
    print(num)
a()
print(num)

函数案例：银行取钱

xxxxxxxxxx
# 初始值定义
money = 100000000
name = None

# 姓名获取
name = input("请输入您的姓名：")

# 定义功能函数
def query():
    '''
    查询余额功能
    :return: 无
    '''
    print("---------查询余额----------")
    print(f"{name}您好，您的余额为：{money}")

def deposit(deposit_money):
    '''
    存款功能
    :param deposit_money:存入金额
    :return: 无
    '''
    global money
    money += deposit_money
    print(f"您存入的金额为：{deposit_money}")
    print(f"您现在的余额为：{money}")

def withdraw(withdraw_money):
    '''
    取款功能
    :param withdraw_money:取款金额
    :return: 无
    '''
    global money
    money -= withdraw_money
    print(f"您取出的金额为：{withdraw_money}")
    print(f"您现在的余额为：{money}")


# 主菜单
while True:
    print("----------主菜单----------")
    print(f"您好{name}，欢迎来到**银行，请选择您要执行的操作")
    print("查询余额\t[输入1]")
    print("存款\t\t[数入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")
    choice = int(input("请输入您的选择:"))
    if choice == 1:
        query()
        print("退出\t\t[输入1]")
        print("返回主菜单\t[输入2]")
        choice_in = int(input("请输入您的选择:"))
        if choice_in == 1:
            break
        else:
            continue
    elif choice == 2:
        deposit_money = int(input("请输入您要存款金额："))
        deposit(deposit_money)
        print("退出\t\t[输入1]")
        print("返回主菜单\t\t[输入2]")
        choice_in = int(input("请输入您的选择:"))
        if choice_in == 1:
            break
        else:
            continue
    elif choice == 3:
        withdraw_money = int(input("请输入您要取出的金额："))
        withdraw(withdraw_money)
        print("退出\t\t[输入1]")
        print("返回主菜单\t[输入2]")
        choice_in = int(input("请输入您的选择:"))
        if choice_in == 1:
            break
        else:
            continue
    elif choice == 4:
        break
    else:
        print("无法识别你输入的数字")
        print("退出\t\t[输入1]")
        print("返回主菜单\t[输入2]")
        choice_in = int(input("请输入您的选择:"))
        if choice_in == 1:
            break
        else:
            continue
print("欢迎下次光临**银行")

数据容器

概念

一份可以容纳多个数据的数据类型，容纳的每一份数据称之为一个元素

每一个元素可以是任意的数据类型

数据容器的特点不同：

·是否支持重复元素

·是否可以修改

·是否有序等

分为五类：列表(list)，元组(tuple)，字符串(str)，集合(set)，字典(dict)

列表

一个列表可以储存做个数据 一次存储多个数据

列表中的每一个数据称之为元素

·以[]作为标识

·列表中的每一个元素用逗号隔开

xxxxxxxxxx
name_list = [1,2,3,'***']
print(name_list)
print(type(name_list))

嵌套列表

xxxxxxxxxx
num_list = [[1,2,3],['*','**','***']]
print(num_list)
print(type(num_list))

列表的下标索引

列表中的每一个元素，从前向后的方向，从0开始依次递增

我们只需要按照下标索引即可取得对应位置的元素

xxxxxxxxxx
list = [1,2,3]
print(list[0])

(反向)

从后往前，从-1依次递减

嵌套列表索引：

xxxxxxxxxx
num_list = [[1,2,3],['*','**','***']]
print(num_list[0][2])
print(type(num_list))

列表的常用操作

方法定义：

xxxxxxxxxx
class P_name:
    def name(self , x , y):
        print("我的姓名是***")
        return x + y

P_name = P_name()
a = P_name.name(1 , 2)

查询功能

index()

xxxxxxxxxx
a = [1,2,3,4,4,5,6,7,8,9]

b = a.index(1)
print(b)

查询下标索引值，如果存在则下标索引值，若不存在则报错

修改元素

语法：列表[下表索引值] = 值

xxxxxxxxxx
a = [1,2,3,4,4,5,6,7,8,9]
a[1] = 66
b = a.index(66)
print(b)

插入元素

语法：列表.insert(下标,元素)，在指定的下标位置插入指定的元素

xxxxxxxxxx
a = [1,3,4,5]
print(a)
a.insert(1,2)
print(a)

追加元素

语法：列表.append(元素)，将指定元素，追加到列表的尾部

xxxxxxxxxx
a = [1,3,4,5]
print(a)
a.insert(1,2)
print(a)
a.append(6)
print(a)

方式2：

语法：列表.extend(其数据容器)，将其数据容器的内容取出，依次追加到列表尾部

xxxxxxxxxx
a = [1,3,4,5]
print(a)
a.insert(1,2)
print(a)
a.append(6)
print(a)
a.extend([7,8,9])
print(a)

删除元素

语法1：

del 列表[下标]

xxxxxxxxxx
a = [1,3,4,5]
del a[0]
print(a)

语法2：

列表.pop(下标)

xxxxxxxxxx
a = [1,3,4,5]
a.pop(0)
print(a)

我们可以通过变量接收取出来的元素

xxxxxxxxxx
a = [1,3,4,5]
b = a.pop(0)
print(b)

删除某元素在列表中的第一个匹配项

语法：

列表.remove(元素)

xxxxxxxxxx
a = [1,3,4,5,1]
b = a.remove(1)
print(a)

清空列表内容

语法：

列表.clear()

xxxxxxxxxx
a = [1,3,4,5,1]
b = a.clear()
print(a)

统计总元素个数

语法：

len()

xxxxxxxxxx
a = ['a',1,1.1]
b = len(a)
print(b)

注意：统计的是全部元素，什么都算上

列表的特点

可以容纳多个元素(上限为2**63-1、9223372036854775807个)

可以容纳不同类型的元素(混装)

数据是有序存储的 (有下标序号)

允许重复数据存在

可以修改(增加或删除元素等)

列表的遍历

while循环：

xxxxxxxxxx
def list_while_func():
    my_list = [1, 2, 3]
    a = 0
    while a < len(my_list):
        b = my_list[a]
        print(f"元素：{b}")
        a += 1

list_while_func()

for循环：

xxxxxxxxxx
def list_for_func():
    my_list = [1, 2, 3]
    for a in range(0,len(my_list)):
        b = my_list[a]
        print(f"元素:{b}")
list_for_func()

while循环和for循环，都是循环语句，但细节不同：

在循环控制上：

while循环可以自定循环条件，并自行控制

for循环不可以自定循环条件，只可以一个个从容器内取出数据

在无限循环上：

while循环可以通过条件控制做到无限循环

for循环理论上不可以，因为被遍历的容器容量不是无限的

在使用场景上：

while循环适用于任何想要循环的场景

for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

总结：

for循环更简单，while循环更灵活

for循环用于从容器内取出元素并处理，while循环用以任何需要循环的场景

列表案例

xxxxxxxxxx
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def while_a():
    b = 0
    d = []
    while b < len(a):
        c = a[b]
        if c % 2 == 0:
            d.append(c)
        b += 1
    return d

f = while_a()

print(f)

元组

元组的定义

定义元祖实用小括号，且使用逗号隔开每个数据，数据可以是不同的数据类型

xxxxxxxxxx
# 定义元组字面量
("**", 1, 2, 2.2)

# 定义元组变量
# 变量名 = （元素， 元素。 元素）
a = ("**", 1, 2, 2.2)

# 定义空元组
'''
方法一：
变量名 = ()
方法二：
变量名 = tuple()
'''

如果定义的元组只有一个元素，在元素后面要写一个逗号，要不他就不是元组类型

元组的嵌套同列表

注意：元组是不可以修改的

可以修改元组内list内的内容

xxxxxxxxxx
a = (1, 2, 3, 4, [1, 2, 3])
a[4][1] = '**'
print(a)

特点：

可以容纳多个数据

可以容纳不同类型的数据(混装)

数据是有序储存的(下标索引)

允许数据重复存在

不可修改(增加或删除元素)

支持for循环

index()

count()

len(元组)

可用