第四篇.python的基础

目录

• 第四篇.python基础01
  • 1. 变量
  • 变化的量：有名字有值
    • 变量 能够描述世间万物的状态，人有年龄的变量，树也有身高的变量，电脑里的等级也有变量的属性，没有变量一切将枯燥无味。
    • 变量名：变量名用来引用变量值，但凡需要用变量值，都需要通过变量名。
    • 赋值符号：赋值
    • 变量值：存放数据，用来记录现实世界中的某种状态
  • 2. 常量
  • 3. python变量内存管理
  • 4. 变量的三个特征
  • 5. 花式赋值
  • 6. 注释
  • 7. 数据类型基础
  • 8. 数字类型
    • 1.1作用
    • 1.2定义
    • 2.1作用
    • 2.2定义
    • 2.3如何用
  • 9. 字符串类型
    • 1.1作用
    • 1.2定义
  • 10. 列表类型
    • 1.1作用
    • 1.2定义
    • 1.3如何用
  • 11. 字典类型
    • 1.1作用
    • 1.2定义
    • 1.3.如何用
  • 12. 布尔类型
    • 1.1作用
    • 1.2定义
    • 1.3如何用
  • 13. 解压缩
    • 1. 定义
  • 14. python与用户交互
    • 1. 为什么交互
    • 2. 如何交互
    • 3. python2的交互
  • 15. 格式化输出的三种方式
    • 1. 占位符
    • 2. format格式化
    • 3. f-String格式化
  • 16. 基本运算符
    • 1. 算数运算符
    • 2. 比较运算符
    • 3. 赋值运算符
    • 4. 逻辑运算符
    • 5. 身份运算符
    • 6. python运算符优先级
  • 17. 流程控制之if判断
    • 1. 语法
    • 2. if的嵌套
    • 3. 练习
  • 18. 流程控制之while
    • 1. 语法
    • 2. while+break
    • 3. while+continue
    • 4. while循环的嵌套
    • 5. tag循环控制退出
    • 6. while+else
  • 19. 流程控制之for循环
    • 1. 语法
    • 2. for+break
    • 3. for+continue
    • 4. for循环嵌套
    • 5. for+else
    • 6. for+循环实现loading

第四篇.python基础01

1. 变量

1. 什么是变量

   变化的量：有名字有值

2. 为什么要有变量？

   变量 能够描述世间万物的状态，人有年龄的变量，树也有身高的变量，电脑里的等级也有变量的属性，没有变量一切将枯燥无味。

3. 定义变量

   name = 'nick'
   age = 19
   gender = 'male'
   height = 180
   weight = 140
   

​

1. 变量的组成

   1. 变量名：变量名用来引用变量值，但凡需要用变量值，都需要通过变量名。

   2. 赋值符号：赋值

   3. 变量值：存放数据，用来记录现实世界中的某种状态

2. 变量名的规范命名

   1. 变量的命名应该能反映变量值所描述的状态，切记不可用中文
   2. 变量名必须用字母数字下划线组合，并且变量名的第一个字符不能是数字。
   3. 关键字不能声明为变量名

3. 变量名的两种格式

   6.1驼峰体

   AgeOfNick = 19
   print(AgeOfNick)
   

   6.2 下划线(推荐)

   age_of_nick = 19
   print(age_of_nick)
   

2. 常量

1. 不变的量 比如人的性别 计算机的π数值

3. python变量内存管理

1. 变量存在哪了

   x=1运行之前只是普通的字符，存在里硬盘里，但是运行py文件的时候，字符就传到了内存，就是说变量存在了内存里；综上所述，运行之前存在硬盘里，运行之后存在内存里

2. python垃圾回收机制

   只要某个变量值绑定着门牌号，就不是垃圾，反之变量值没有绑定着门牌号，这个变量值就是垃圾，python就会自动清理这个垃圾。

3. 小整数池

   Python实现int的时候有个小整数池。为了避免因创建相同的值而重复申请内存空间所带来的效率问题， Python解释器会在启动时创建出小整数池，范围是[-5,256]

4. 变量的三个特征

1. 打印

   x = 10
   print(x)  # 获取变量的变量值
   

2. 判断变量值是否相等

   name1 = 'egon'
   name2 = 'nick'
   print(name1 == name2)  # False
   

3. 判断变量id是否相等

   x = 11
   y = x
   z = 11
   print(x == y)  # True
   

   print(x is y)  # True
   

   True
   

   print(x is z)  # True，整数池的原因
   True
   x = 257
   z = 257
   print(x is z)  # False
   

5. 花式赋值

1. 链式赋值

   a = 10
   b = 10
   c = 10
   d = 10
   print(f'a:{a}, b:{b}, c:{c}, d:{d}')
   

   a:10, b:10, c:10, d:10
   

2. 交叉赋值

   
    x = 100
    y = 200
    temp = x
    x = y
    y = temp
    print(f'x:{x}')
    print(f'y:{y}')
   

   x:200
   
   y:100

   x, y = y, x
   print(f'x:{x}')
   print(f'y:{y}')
   

   x:100
   
   y:200

6. 注释

1. 注释

   # 单行注释
   
   '''
   三单引号注释
   三单引号注释
   '''
   
   """
   三双引号多行注释
   三双引号多行注释
   

2. 添加赋值的原则

   1. 不用全部加注释，只需要在自己觉得重要或不好理解的部分加注释即可
   
   2. 注释可以用中文或英文，但不要用拼音

7. 数据类型基础

1. 什么是数据类型

   数据类型指的是变量值的不同类型，姓名可能是一种数据类型，年龄可能是数据类型。。。

2. 为何对数据分类

   变量是用来反映状态变化的，不同的状态就应该用不同类型的数据去标识。

3. 不同数据类型

   数字类型

   字符串类型

   列表类型

   字典类型

   布尔类型

8. 数字类型

1. 整型int

   1.1作用

   可以表示年龄、号码、级别

   1.2定义

   age = 18  # age=int(18)
   print(id(age))
   print(type(age))
   print(age)
   

2. 浮点型float

   2.1作用

   可以表示身高体重、薪资

   2.2定义

   salary = 2.1  # salary=float(2.1)
   
   print(id(salary))
   print(type(salary))
   print(salary)
   

   2.3如何用

   加减乘除、逻辑判断（大于、小于）

9. 字符串类型

1. 字符串（str）

   1.1作用

   可以表示名字爱好

   1.2定义

   相当于一根羊肉串，字符串就是一串被串起来的字符，在单引号、双引号、三引号包裹的一串字符，除了三引号可以换行，单双的字符不行

   salary = 2.1  # salary=float(2.1)
   
   print(id(salary))
   print(type(salary))
   print(salary)
   

   name3 = """nick
   egon"""
   
   print(name3)
   

2. 如何用

   字符串只能+-和逻辑比较

   msg2 = "my name is 'nick'"
   msg3 = 'my name is "nick"'
   
   print(msg2 + msg3)  # my name is 'nick'my name is "nick"
   

   注意：字符串的拼接，就是重新申请空间，把两个字符串都拷贝一份后再拼接

   str='"hello"'
   

   注意：如果字符串内有引号，则包裹的字符串的引号不能和字符串内部的引号的一样

   name = 'nick '
   print(name * 10)
   

   注意：字符串的乘法只能乘以数字

   msg1 = 'hello'
   msg2 = 'z'
   
   print(msg1 > msg2)
   

   注意：字符串比较大小，按照ascll码比较

   msg3 = 'zero'
   msg4 = 'zx'
   
   print(msg3 > msg4)
   print('Z' > 'A')
   print('Z' > 'a')
   

   注意：字符串的比较是字母的顺序

   False

   True

   False

10. 列表类型

1. 列表（list）

   1.1作用

   存放多个值，多个爱好

   1.2定义

   在[]内用逗号隔开任意类型的值

   hobby = 'read'
   hobby_list = [hobby, 'run', 'girl']
   print(id(hobby_list))
   print(type(hobby_list))
   print(hobby_list)
   

   4558605960

   <class 'list'>

   ['read', 'run', 'girl']

   1.3如何用

   存不是目的，取才是目的，列表索引序号从0开始

   hobby_list = ['read', 'run', 'girl']
   # 索引序号      0       1      2
   # 取出第二个爱好
   print(hobby_list[1])
   

   run

   hobby_list = ['read', 'run', ['girl_name', 18, 'shanghai']]
   # 取出girl的年龄
   print(hobby_list[2][1])
   

   18

11. 字典类型

1. 字典（dict）

   1.1作用

   用来存取多个值，但我们能通过列表取值，是因为我们知道列表内所有的元素。那我们可以给列表内的每个元素添加一个描述信息。于是有种新的数据类型---字典。

   按照key:value的方式存值，取得时候可以通过key而非索引取值，key对value有描述性的作用。存放各种并且数据较多的时候可以用字典。

   1.2定义

   在{}内用逗号隔开多个元素，每个元素都是key:value的格式，其中value是任意格式的数据类型，key具有描述性的作用，key通常是字符串类型

   user_info = {'name': 'nick', 'gender': 'male', 'age': 19,
                'company_info': ['oldboy', 'shanghai', 50]}
   
   print(id(user_info))
   print(type(user_info))
   print(user_info)
   

   4396183344

   <class 'dict'>

   {'name': 'nick', 'gender': 'male', 'age': 19, 'company_info': ['oldboy', 'shanghai', 50]}

   1.3.如何用

   由于字典取值方式不再依赖于索引，而是依赖于key，通过key可以获取key对应的value值

   字典套列表

   user_info = {'name': 'nick', 'gender': 'male', 'age': 19,
                'company_info': ['oldboy', 'shanghai', 50]}
   print(user_info['name'])
   print(user_info['company_info'][0])
   

   nick

   oldboy

   字典套字典

   user_info = {'name': 'nick', 'gender': 'male', 'age': 19, 'company_info': {
       'c_name': 'oldboy', 'c_addr': 'shanghai', 'c_num_of_employee': 50}}
   
   print(user_info['name'])
   print(user_info['company_info']['c_name'])
   

   nick

   oldboy

2. 练习

   取出第二个学生的名字

   student=[{'name':'ypp'，'age':'18'},{'name':wwb,'age':20}
   print(student[1]['name'])
   

   wwb

12. 布尔类型

1. 布尔值

   1.1作用

   用于判断条件结果

   1.2定义

   Ture,False通常不会直接引用，需要使用逻辑运算得到结果

   1.3如何用

   print(type(Ture))
   

   <class 'bool'>

   print(bool(0))
   print(bool('nick'))
   print(bool(1 > 2))
   print(bool(1 == 1))
   

   False

   True

   False

   True

   注意：Python中所有数据类型的值自带布尔值。如此多的数据类型中只需要记住只有0、None、空、False的布尔值为False，其余的为True。

   print(bool(0))
   print(bool(None))
   print(bool(''))
   print(bool([]))
   print(bool({}))
   print(bool(False))
   

   结果是

   False
   False
   False
   False
   False
   False
   

13. 解压缩

1. 定义

理解为：超市打包把多个商品放在一起，解压缩其实就是捷报把多个商品一次性拿出来

name_list = ['nick', 'egon', 'jason', ]
x, y, z = name_list
print(f'x:{x}, y:{y}, z:{z}')

x:nick, y:egon, z:jason

有时候可以下划线来屏蔽不想要的值

name_list = ['nick', 'egon', 'jason', 'tank']
x, y, z, a = name_list
x, _, z, _ = name_list  # _相当于告诉计算机不要了，不能以_开头和结尾
x, y, *_, z = name_list

把字典解压缩的结果是字典的key

   info = {'name': 'nick', 'age': 18}
   x, y = info
   print(x, y)

name age

14. python与用户交互

1. 为什么交互

当我们要在ATM取款时，输入密码输入金额，这种叫做交互。没有交互无法取款

2. 如何交互

info = {'name': 'nick', 'age': 18}
x, y = info
print(x, y)

3. python2的交互

name = raw_input('请输入你的姓名：')
pwd = raw_input('请输入你的密码：')

print(type(name))  # 'str'
print(type(pwd))  # 'str'

注意：py2的raw_input和py3的input是一样的

15. 格式化输出的三种方式

1. 占位符

占位符指的是%s（针对所有数据类型）、%d（仅仅针对数字类型）

   age=20
   sarlay=1500
   print('我叫%s,年龄%s,工资%s'%(name,age,sarlay))

2. format格式化

   name="ypp"
   age=20
   sarlay=1500
   print('我叫{0},年龄{1},工资{2}'.format(name,age,sarlay))

注意：{}里面可以不填，可以填变量名，也可以写索引序号

3. f-String格式化

name="ypp"
age=20
sarlay=1500
print(f'我叫{name},年龄{age},工资{sarlay}')

16. 基本运算符

1. 算数运算符

加减乘除

2. 比较运算符

pwd = '123' print(pwd != '123')#False print(pwd == '123')#True

l1 = [1, 'a', 3] l2 = [1,'2'] print(l1 < l2)#列表同一个位置必须是同一个数据类型 False

3. 赋值运算符

age = 19
age = age + 1 #20
age *=10 #200
age /=2 #100
print(age)

4. 逻辑运算符

# 从左到右的方式找到逻辑运算符，找到逻辑运算符的左边，左边成立，再去找到逻辑运算符的右边
print(3 > 3 and 1 > 2 or 2 > 1)  # True

5. 身份运算符

6. python运算符优先级

# Python中True为1，False为0
print(True > 0)  # True
print(True > 2)  # Flase

17. 流程控制之if判断

1. 语法

1.1 if

if 条件：

​ 代码块

1.2 if ...else

if 条件:

​ 代码块

else:

​ 代码块

1.3 if...elif...else

if 条件1:
    代码1
    代码2
    代码3
    ...
elif 条件2:
    代码1
    代码2
    代码3
    ...
elif 条件3:
    代码1
    代码2
    代码3
    ...
...
else:
    代码1
    代码2
    代码3
    ...

2. if的嵌套

if 条件1: 条件1不成立则执行代码1 成立则执行if 条件1的代码块；

	if 条件2: 条件2成立则执行代码块1，再执行代码1

		代码块1

代码1

3. 练习

• 如果 成绩>=90，打印"优秀"

• 如果 成绩>=80 并且 成绩<90，打印"良好"

• 如果 成绩>=70 并且 成绩<80，打印"普通"

• 其他情况：打印"差"

  score = input("your score: ")
  score = int(score)
  
  if score >= 90:
      print('优秀')
  # elif score >= 80 and score < 90:
  elif score >= 80:
      print('良好')
  # elif score >= 70 and score < 80:
  elif score >= 70:
      print('普通')
  else:
      print('差')
  

  3.2练习

  user_from_db = 'nick'
  pwd_from_db = 123
  
  user_from_inp = input('username: ')
  user_from_inp = input('password: ')
  
  if user_from_inp == user_from_db and pwd_from_inp == pwd_from_db:
      print('login successful')
  else:
      print('username or password error')
  

  username: nick

  password: 123

  username or password error

18. 流程控制之while

1. 语法

重复做同一件事。ATM验证失败的时候，会让我们重新输入密码账号，这个叫做while循环，又称为条件循环。

while 条件
    code 1
    code 2
    code 3
    ...

while True:
    print('*1'*100)
    print('*2'*100)

# 实现ATM的输入密码重新输入的功能
while True:
    user_db = 'nick'
    pwd_db = '123'

    inp_user = input('username: ')
    inp_pwd = input('password: ')
    if inp_user == user_db and pwd_db == inp_pwd:
        print('login successful')
    else:
        print('username or password error')

上述代码虽然实现了功能，但是用户密码输对了，他也会继续输入

2. while+break

break的意思是终止掉当前层的循环，执行其他代码。

while True:
    print('1')
    print('2')
    break
    print('3')

1

2

上述代码的break毫无意义，循环的目的是为了让计算机和人一样工作，循环处理事情，而他直接打印1和2之后就退出循环了。而我们展示下有意义的while+break代码的组合。

while True:
    user_db = 'nick'
    pwd_db = '123'

    inp_user = input('username: ')
    inp_pwd = input('password: ')
    if inp_user == user_db and pwd_db == inp_pwd:
        print('login successful')
        break
    else:
        print('username or password error')

print('退出了while循环')

username: nick

password: 123

login successful

退出了while循环

3. while+continue

continue的意思是终止本次循环，直接进入下一次循环

n = 1
while n < 4:
    print(n)
    n += 1

1

2

3

n = 1
while n < 10:
    if n == 8:
        # n += 1  # 如果注释这一行，则会进入死循环
        continue
    print(n)
    n += 1

continue不能加在循环体的最后一步执行的代码，因为代码加上去毫无意义，如下所示的continue所在的位置就是毫无意义的。ps：注意是最后一步执行的代码，而不是最后一行。

while True:
    if 条件1:
        code1
        code2
        code3
        ...
    else:
        code1
        code2
        code3
        ...

    continue

4. while循环的嵌套

# 退出内层循环的while循环嵌套
while True:
    user_db = 'nick'
    pwd_db = '123'

    inp_user = input('username: ')
    inp_pwd = input('password: ')

    if inp_user == user_db and pwd_db == inp_pwd:
        print('login successful')

        while True:
            cmd = input('请输入你需要的命令：')
            if cmd == 'q':
                break
            print(f'{cmd} 功能执行')
    else:
        print('username or password error')

print('退出了while循环')

# 退出双层循环的while循环嵌套
while True:
    user_db = 'nick'
    pwd_db = '123'

    inp_user = input('username: ')
    inp_pwd = input('password: ')

    if inp_user == user_db and pwd_db == inp_pwd:
        print('login successful')

        while True:
            cmd = input('请输入你需要的命令：')
            if cmd == 'q':
                break
            print(f'{cmd} 功能执行')
        break
    else:
        print('username or password error')

print('退出了while循环')

5. tag循环控制退出

# tag控制循环退出
tag = True
while tag:
    user_db = 'nick'
    pwd_db = '123'

    inp_user = input('username: ')
    inp_pwd = input('password: ')

    if inp_user == user_db and pwd_db == inp_pwd:
        print('login successful')

        while tag:
            cmd = input('请输入你需要的命令：')
            if cmd == 'q':
                tag = False
            print(f'{cmd} 功能执行')
    else:
        print('username or password error')

print('退出了while循环')

username: nick

password: 123

login successfu

6. while+else

while+else：else会在while没有被break时才会执行else中的代码

# while+else
n = 1
while n < 3:
    print(n)
    n += 1
else:
    print('else会在while没有被break时才会执行else中的代码')

1

2

19. 流程控制之for循环

1. 语法

while 和for循环很类似，但区别在于：while容易死循环，是不可控的，for不容易进入死循环，是可控的

name_list = ['nick', 'jason', 'tank', 'sean']

n = 0
while n < 4:
    # while n < len(name_list):
    print(name_list[n])
    n += 1

nick
jason
tank
sean

字典可能也有多个值的需求，字典可能有while无法使用的，可以用到for循环

info = {'name': 'nick', 'age': 19}

for item in info:
    # 取出info的keys
    print(item)

注意：字典for循环的是key键

ame_list = ['nick', 'jason', 'tank', 'sean']
for item in name_list:
    print(item)

nick
jason
tank
sean

之所以for是可控的，是因为容器类型的长度是有限的，但while的循环需要自己控制，for循环也可以按照索引取值

print(list(range(1, 10)))

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

for i in range(1, 10):  # range顾头不顾尾
    print(i)

1
2
3
4
5
6
7
8
9

# for循环按照索引取值
name_list = ['nick', 'jason', 'tank', 'sean']
# for i in range(5):  # 5是数的
for i in range(len(name_list)):
    print(i, name_list[i])

0 nick
1 jason
2 tank
3 sean

2. for+break

# for+break
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
    if name == 'jason':
        break
    print(name)

nick

3. for+continue

or循环调出本次循环，进入下一次循环

# for+continue
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
    if name == 'jason':
        continue
    print(name)

nick
tank
sean

4. for循环嵌套

# for循环嵌套
for i in range(3):
    print(f'-----:{i}')
    for j in range(2):
        print(f'*****:{j}')

-----:0
*****:0
*****:1
-----:1
*****:0
*****:1
-----:2
*****:0
*****:1

5. for+else

# for+else
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
    print(name)
else:
    print('for循环没有被break中断掉')

nick
jason
tank
sean
for循环没有break中断掉

6. for+循环实现loading

#只能用于jupyter notebook
import time

print('Loading', end='')
for i in range(6):
    print(".", end='')
    time.sleep(0.2)