【2022-06-26】上周内容回顾

本周内容回顾

Python语法注释及变量与常量

Python语法注释

语法注释，是指程序员对自己编写的代码进行的一种说明，类似于一种标识，可以更加直观简洁的了解此行代码所代表的意思
在python中，语法注释分为两种，一种是单行注释，一种是多行注释
单行注释，通常用#号(按住shift+#)来表示，注释的内容如果是单独一行时，#号后边空一格，注释的内容如果是在语法后边，为了保证代码的可读性，

建议空两格，这也遵循了PEP8规范使用
多行注释，通常使用三个单引号'''和三个双引号"""来使用，当需要注释的内容过多时，单行注释无法满足需求，就需要用到多行注释

变量与常量的概念

变量就是指在程序运行的过程中，发生变化的数据值
常量就是指在程序运行的过程中，不会发生变化的数据值

基本使用：

name = '张三'
age  = 36
gender = 'man'

语法结构：

name = '张三'

变量名  赋值符号  数据值  遇到赋值符号，先看右边再看左边

name是变量名，=是赋值符号，张三是数据值，这句话的意思就是把数据值张三赋值给变量名name

无论是变量还是常量，它都是存储在内存空间里，那么我们是如何进行调用的呢？

首先，我们向内存空间申请一块内存空间，用于存储我们的数据值张三
然后，给这个内存空间绑定一个变量名name
这样我们就可以通过变量名name访问到我们需要的数据值张三
如果内存空间中的数据值没有被任何变量名绑定，那么这个数据值就是所谓的垃圾数据！！！

变量的命名规范

变量名的命名规范：只能出现字母、数字以及下划线
```
username_123 = 'huawei'
username123 = 'timi'
```
数字不能开头
```
123age = 18  # 这是无法打印的
```

命名不能与python中的关键字冲突

range = 'hhh'  # 这是不可行的，range是python中的一种函数，无法当做变量名来使用，其余还有很多，自行摸索

尽量做到见名知意

hobby = 'study'  # 直观的一种表现方式，通俗易懂

变量的命名风格

变量的命名风格：下划线式和驼峰体式
下划线式
```
user_name_for_mysql = 'xxx'  
```

驼峰体式

大驼峰体：
UserNameForMysql = 'xxx'   # 首字母开头大写

小驼峰体：
userNameforMysql = 'xxx'   # 首字母不大行，第二个字母大写

Python数据类型

数据类型之整型int

整型就是用来存储整数数据值，也就是我们通常使用的整数，可以是正数，也可以是负数，表达关键字为int
应用场景：电话号码、年龄、人数

基本使用：

phone_number = 10086
age = 18
pepole_number = 100

数据类型之浮点型float

浮点型就是用来存储小数数据值，也就是我们通常使用的小数，表达关键字是float
应用场景：商品的价格、体重、圆周率

基本使用：

price = 18.8
weight = 55.4
pi = 3.1415926

数据类型之字符串str

字符串可以当做是文本文件，表达关键字是str
应用场景：事物的描述、属性、关系等

基本使用：

red = '红色'
address = '上海'
student = '学生'

数据类型之列表list

定义以及作用：列表是通过方括号括起来，里边存放多个数据值，数据值与数据值之间用逗号隔开的一种表达式，一个列表里可以包含不同类型的数据

值，它的作用就是可以一次性存放多个数据值，程序员可以通过列表来进行一系列的增删查改操作

基本使用

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, '西游记', '三国演义']

类型描述

使用中括号括起来，里边存放多个数据值，数据值与数据值之间用逗号隔开，数据值可以是任意类型的数据

取值方式

索引取值，是通过索引的方式对列表内的数据值进行获取的操作，列表中的每个数据值都有一个编号，即其索引
索引的取值方式，在IT行业，数字的起始位置大多数都是从0开始的，按照从左往右的取值方式依次进行取值，第一个位置是0，第二个位置是1，以此类推
eg：在以下列表中，我想取到西游记
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, '西游记', '三国演义']
print(list[9])

数据类型之字典dict

定义以及作用：字典是一种可变的容器类型，它可以存储任意数据类型，在大多数情况下，字典存储的相关信息是用来描述事物的信息，它的作用就是

可以存储多个数据值，程序员可以通过访问字典来拿到对应的信息，但是字典多了一个对数据值的解释说明

基本使用

info_dict = {'name':'lisa', 'age': 18, 'job':'诗人', 'dynasty':'唐朝'}

类型描述

字典以键值对存储数据，即key-value形式，键值之间用冒号隔开，每个键值中间用逗号隔开
大括号括起来，内部存放多个数据值，数据值与数据值之间用逗号隔开，数据值可以是任意数据类型，数据的组织形式是K:v键值对
k是对v的描述性质的信息，一般是字符串
V是真实的数据值，可以是任意数据类型

取值方式：按K取值

info_dict = {'name':'lisa', 'age': 18, 'job':'诗人', 'dynasty':'唐朝'}
print(info_dict[age])                               # 18

与列表不同的是，字典无法通过索引进行取值，因为字典内部是无序的

数据类型之布尔值bool

定义以及作用：布尔值是逻辑值，只有两种形式：真True、假Flase，可以用于判断条件的结果

基本使用

is_successfully = True
is_defeated = Flase

print(if_successfully)               # True     
print(if_defeated)                   # Flase

类型描述

布尔值看似很少见，但是在程序中的运用很常见，使用频率很高，布尔值的名字一般以is开头

布尔值类型转换

在python中，所有的数据类型都可以转换为布尔值，只有0、None、空列表、空字典的布尔值为False，其余都是True

数据类型之元组tuple

定义以及作用：元组与列表类似，不同的是列表使用中括号，元组使用小括号，元组也称为是不可变的列表，它可以通过索引获取多个数据值，但是

只能用于读取，不能进行修改；而列表是可存可取，同时也可以进行修改
基本使用
```
list1 = (1, 2, 3, 4, 5)
```

类型描述

用小括号括起来，内部存放多个数据值，数据值与数据值之间用逗号隔开，数据值可以是任意数据类型

与列表的区别

list1 = ['洪家铁线拳', '十二路谭腿', '五郎八卦棍', '如来神掌', ]

list2 = ('东邪', '西毒', '南帝', '北丐')

print(list1[2])              # 五郎八卦棍
print(list2[1])           # 西毒

list1[2] = '咏春拳'           # 将列表索引2重新绑定数据值咏春拳
print(list1)                 # ['洪家铁线拳', '十二路谭腿', '咏春拳', '如来神掌']


list2[1] = '郭靖'            # 将列表索引1的值重新绑定数据值郭靖   打印直接报错！！！

数据类型之集合set

定义以及作用：集合是一个无序的，不可重复的元素序列。集合使用大括号{}将数据括起来，数据值与数据值之间用逗号隔开，从数据结构上看，集合与

列表和元组类似，从元素上看，集合与字典类似，即元素不允许重复，集合可以用于去重以及关系运算
基本使用
```
st = {'python', 'java', 'C++', 'PHP'}
```

类型描述

用大括号括起来，内部存放多个数据值，数据值与数据值之间用逗号隔开，数据值可以是任意数据类型，数据值不可重复

如何定义空集合

空集合只能用set()来创建，大括号是用来创建集合的
st = set()
print(type(st))       # <class 'set'>

用户交互与输出格式化

用户交互的定义

用户交互就是人与计算机之间的一种沟通形式，人往计算机输入input数据，计算机返回输出print数据结果，交互的本质就是输入、输出

如何进行用户交互

输入：input 向计算机传递信息

在python中input会等待用户输入，用户输入任何内容都会变成字符串，然后赋值给等号左边的变量名。input接收一个参数用来向用户显示提示或说明信息

username = input('请输入您的用户名>>>:')
print(username)                # 请输入您的用户名>>>:tony 

输出：print 计算机返回数据结果

print可以输出一个数据值，也可以输出多个数据值，数据值之间用逗号隔开，可以直接放数据值，也可以放变量名

print(1)                             # 1
print('hello', 'word')               # hello word

name = 'tony'
print(name)                          # tony

此外，print功能还有一个end参数，该参数的默认值为"\n"(换行)，可以将end参数的值转换为任意数据类型的字符

print('你好', end='-')
print('狗东西')                       # 你好-狗东西

格式化输出的定义以及使用

格式化输出，就是按照格式说明所描述的文字规则进行输出

格式化输出的使用：

# # 1.获取用户信息并打印出下列格式
# # ------------ info-of-XXX -----------
# # Name: XXX
# # Age: XXX
# # Job: XXX
# # dynasty: xxx 
# # another_name: xxx
# # production: xxx
# # ------------- end -------------------
# 
# 
# 
# # 1.格式化输出:提前准备好文本
# 
# info = """
#     ------------ info of %s -----------
#         Name           : %s
#         Age            : %s
#         Job            : %s 
#         dynasty        : %s 
#         another_name   : %s
#         production     : %s
#         
#     ------------- end -------------------
#     """
# # 2.获取用户数据
# 
# name = input('请输入您的姓名>>>:')
# age = input('请输入您的年龄>>>:')
# job = input('请输入您的工作>>>:')
# dynasty = input('请输入您的出生地>>>:')
# another_name = input('请输入您的别称>>>:')
# production = input('请输入您的著作>>>:')
# 
# # 3.格式化输出
# 
# print(info % (name, name, age, job, dynasty, another_name, production))
# 
# 
# # 4.输出结果
# 
# # 请输入您的姓名 >> >: 李白
# # 请输入您的年龄 >> >: 999
# # 请输入您的工作 >> >: 诗人
# # 请输入您的出生地 >> >: 唐朝
# # 请输入您的别称 >> >: 诗仙
# # 请输入您的著作 >> >: 李太白集
# # 
# # ------------ info-of-李白 - ----------
# # Name: 李白
# # Age: 999
# # Job: 诗人
# # dynasty: 唐朝
# # another_name: 诗仙
# # production: 李太白集
# # 
# # ------------- end - ------------------


这里就用到一个新的知识点，叫做占位符

%s占位符：可以接收任意类型的数据值
%d占位符：只能接收数字，即整型和浮点型的数据值

如何查看数据类型

在python中，查看数据类型的命令为print(type(跟上变量名))

print(type(phone_number))      # <class 'int'>
print(type(price))             # <class 'float'>

Python常见运算符与流程控制

基本运算符

什么是运算符

举个例子：1+2=3 (1和2是操作数，+就是运算符)

常见的运算符有哪些

算术运算符：

加 + 
减 - 
乘 * 
除 /
整除 //
取模 %
幂指数 **(次方)

x = 10
x = x + 100  # x += 100
x = x - 10   # x -= 10
x = x * 10   # x *= 10
x = x / 10   # x /= 10


比较运算符

==	 等于
!=  不等于

赋值符号

# x = 10
# y = x
# z = y
# 链式赋值
x = y = z = 10   # 给数据值绑定一个初始变量名x，把x绑定给变量名y，在把y绑定给变量名z，最后得出的结果就是z=10，这就是链式赋值


m = 999
n = 100
# 让m绑定n绑定的数据值 让n帮忙m绑定的数据值
# m = n
# n = m
# print(m)
# print(n)

'''方式1:利用中间变量'''
# tmp = m
# m = n
# n = tmp
# print(m, n)

'''方式2:交叉赋值'''
m, n = n, m
print(m, n)


name_list = ['jason', 'tony', 'kevin']
# 用三个不同的名字存储三个不同的人名
# name1 = name_list[0]
# name2 = name_list[1]
# name3 = name_list[2]

'''解压赋值:赋值符号的左边至少要有两个及以上的变量名 才能称之为解压赋值'''

# name1, name2, name3 = name_list

# 1.上述操作需要保证左边的名字和右边的数据值 个数一致
# a, b = name_list                # 打印错误，不符合规范
# a, b, c, d, e = name_list       # 打印错误，不符合规范

"""特殊情况 解压的数据非常的多"""

l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]
# a, b, *c, d = l1  # *在解压赋值的时候会自动将多余的数据值组织成列表赋值给*号后面的变量名
# print(a)  # 11
# print(b)  # 22
# print(c)  # [33, 44, 55, 66, 77, 88]
# print(d)  # 99
*c, a, b = l1
print(a)        # 88
print(b)        # 99

逻辑运算符

逻辑运算符用于多个条件的连接，在程序中，经常会用逻辑运算符来进行多个条件的判断，其运算结果只有两种真True、假Flase

逻辑运算符有三种：与and、或or、非not

# a and b    # 当a和b的值均为True时，逻辑表达式为True，否则为False

举例：

# 假设变量a为10，b为20

a = 10 
b = 20

if a and b :
    print("变量a和变量b都为True")        # 如果a为True， a和b返回值为True， 否则它将返回b的计算值  (a and b)返回10
else:
    print("变量a和变量b 有一个不为True")  # 如果a为False，a和b返回值为False，否则它将返回b的计算值  (a and b)返回20
    
    


# a or b     # 当a和b之中至少有一个为True时，逻辑表达式为True，否则为False

举例：

# 假设变量a为10，b为20

a = 10
b = 20

if a or b :
    print("变量a和变量b都为True,或其中一个变量为True")  # 如果a和b都为True，或其中一个变量为True，则运算结果为True  (a or b)返回10或20
else:
    print("变量a和b都不为True")                       # 如果a和b都不为True，则返回值为False
    
    

# not a      #  当a为True时，逻辑表达式结果为False；当a为False时，逻辑表达式结果为True

举例：

# 假设变量a为10，b为20

a = 10
b = 20

if not (a and b):
    print("变量a和变量b都为False,或其中一个变量为False")   
else:
    print("变量a和b都为True")                    #  如果a为True，则返回False。如果a为False，则返回True

成员运算符

成员运算符是用来识别某一元素是否包含在变量中，这个变量可以是字符串、列表、元组
成员运算符也包含两种运算符in和not in
in：在指定的序列中是否包含元素，如果是返回True，否则返回False

not in：在指定的序列中没有找到元素，则返回True，否则返回False

# 假设变量a为10，b为20，列表内是否包含变量a和b

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print (" 变量 a 在给定的列表中 list 中")
else:
   print (" 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print (" 变量 b 不在给定的列表中 list 中")
else:
   print (" 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值，在进行查看
a = 2
if ( a in list ):
   print (" 变量 a 在给定的列表中 list 中")
else:
   print (" 变量 a 不在给定的列表中 list 中")

身份运算符

身份运算符是用来判断两个对象的存储单元是否相同的一种运算符号
身份运算符也包含了两种运算符号：is和not is，返回的结果都是True或者False
is是判断两个标识符是不是引用自同一个对象，如果是则返回True，否则返回False

not is是判断两个标识符是不是引用自不同的对象，如果是则返回True，否则返回False

假设a = 1, b = 2, c=a, a和b这两个变量存储的内容是不一样的，所以存储单元肯定不一致，但是c和a其实都是1，因为这两个变量的存储单元是一致的

a = 1
b = 2
c = a
print(a is b)                       # False
print(a is c)                       # True


a = 1
b = 2
c = a
print(a is not b)                   # True
print(a is not c)                   # False

流程控制简介

简单理解，流程控制就是控制程序中的代码按照指定的结构顺序来执行，从而实现我们需要的功能
流程控制主要有三种结构：
1. 顺序结构：
  
  指程序的执行顺序是自上而下依次执行语句的结构
2. 分支结构
  
  指程序在自上而下执行代码的过程中，根据不同的条件，执行不同路径的代码，从而得到不同的结果，通常使用if语句来实现分支结构
3. 循环结构
  
  根据判断条件来重复性的执行某段代码，通常使用while语句和for语句实现循环结构

流程控制之if分支结构

Python中的if else语句可以分为三种形式，分别是if语句、if else语句、if elif else语句
if语句也称为单分支结构

语法结构

if条件：

满足条件后执行的代码

举例：

# 1.先定义一个年龄
age = 24
# 2.判断人物的年龄
if age < 24:
    print('永远年轻，永远热泪盈眶')

if+else语句

语法结构

if 条件：

满足条件后执行的代码

else:

不满足条件后执行的代码

举例：

# 1.先定义一个年龄
age = 18
# 2.判断人物的年龄
if age > 18:
    print('年轻不是挥霍的资本')
else:
    print('永远年轻，永远热泪盈眶')

if+elif+else语句

语法结构

if条件

满足条件后执行的代码

elif:

第一个条件不成立后执行代码

elif:

第二个条件不成立后执行的代码

else：

上述条件均不成立后执行的代码

举例：

# 先定义一个成绩
score = 73
if score > 90:
    print('优秀')
elif score > 80:
    print('良好')
elif score > 70:
    print('一般')
elif score > 60:
    print('及格')
else:
    print('不及格')

if嵌套使用

# 比如你去面试了，先进行的是笔试
# 笔试通过了，进行面试
# 进行第二次面试
# 没通过，别气馁，找下一家

# 1.先定义条件

is_written = True   # 笔试通过
is_Interview = True  # 一面通过
is_Second_interview = True  # 二面未通过
is_not_pass = False   # 未通过

# 2.进行条件判断

if is_written:
    print('恭喜你在此次笔试中脱颖而出')
    if is_Interview:
        print('恭喜你通过了第一轮的面试')
        if is_Second_interview:
            print('恭喜你通过了第二轮的面试')
            if is_not_pass:
                print('抱歉，您未能通过我们的考核')
            else:
                print('没关系，拜拜就拜拜，下一家')
        else:
            print('可惜了，有几道题没答好')
    else:
        print('唉！回炉再造吧')
else:
    print('这家不行，换下一家')

Python流程控制之while循环

循环的定义以及作用

循环是我们经常会用到的一个概念，在现实生活中，有许多的场景其实都是在不断的做着重复的事情，比如流水线的工人，我们平时的吃饭睡觉等等
在python中，提供了两种循环语句，分别是while循环和for循环

while循环基本使用

while循环是首先判断循环条件，如果条件满足则执行循环体语句，再判断循环条件.......一直到循环条件不满足后才执行循环体下面的语句

while 条件:
 
    条件成立重复执行的代码1
 
    条件成立重复执行的代码2
 
    ......

#  案例1：打印1-100的所有数字
# 
count = 1              # 先定义一个变量名称count并给它赋值为0
while count < 101:     # 设置循环的条件是count的值小于100
    print(count)       # 打印count的值
    count += 1         # count的值+1



#  案例2：打印1-100的数字累加和 1+2+3+4...+100
# 
total = 0                         # 设置总和的起始值为0
number = 1                        # 设置计数的起始值为1
while number <= 100:              # number大于100时停止计算
    total += number               # 每循环一次，在原有的基础上加上当前的计数值
    number += 1                   # 每循环一次，计数+1
print(total)                      # 打印结果  5050

while循环的执行流程

先判断while循环后面的条件是否满足，如果条件满足则执行循环体代码
循环体代码运行完毕后，再次回到while循环后面的条件进行判断，判断条件是否满足
如果条件满足则继续执行循环体代码，之后再次判断while循环后面的条件是否满足
依次类推，直到条件不满足才会结束循环，然后执行循环体下面的代码

while+break语句

程序运行至break的时候，结束本层循环

# 打印数字1-10 ,遇到6就终止循环

number = 1
while number <= 10:

    if number == 6:
        break

    print(number)

    number += 1

while+continue语句

程序运行至continue的时候，跳过本次循环，执行下一次循环

# 打印数字1-10,不包括4

number = 1
while number <= 10:

    if number == 4:
        # 手动加1 , 防止跳过下面代码,忽略自增形成死循环;
        number += 1
        continue
    print(number)
    number += 1

while+else语句

如果不在满足循环的条件，则立即执行else后面的语句

# 打印1-10的数字，并在最后告知数字打印已完成 

count = 1                    # 先定义一个变量名称count并给它赋值为0
while count < 10:            # 设置循环的条件是count的值小于10
    print(count)             # 打印count的值
    count += 1               # count的值+1
else:                        # 当count小于10的条件无法满足时，执行else后的语句
    print('数字打印已完成')

while死循环与全局标志位

如果条件判断语句永远为True，循环将会一直执行下去，形成死循环
```
# 死循环

while True:
    print(666)
```

Python流程控制之for循环

for循环的定义以及作用

首先我们知道，循环就是重复的做某些事情，而for循环是编程语言中提供的一种循环机制，需要多次重复执行的代码，都可以用for循环来完成

for循环基本使用

for循环的语法结构

for 变量名 in 可迭代对象:     #可迭代对象可以是：列表，字典，字符串，元组，集合
循环体语句

基本使用：
定义一个列表：l2 = [11, 22, 33, 44, 55]
for i in l2:
     print(l2)

for循环基本使用之列表循环取值

l3 = ['张三','李四','王五']
for a in l3:
     print(a)
	
打印结果：张三
         李四
         王五
         
eg:for循环打印列表时，默认取到的值是列表中的每一个数据值

for循环基本使用之字典循环取值

user_dic = {'height': 183, 'weight': 55, 'address': 'shanghai'}
for k in user_dic:
    print(k)
    
 打印结果：height
 	  weight
 	  address
 	  
 eg:for循环字典 默认只能取到字典的key

for循环基本使用之字符串循环取值

info = ‘you are my best frined’
for i in info:
	print(i)

eg:for循环字符串 默认每次取单个字符

for循环基本使用之元组循环取值

l4 = ('11', '22', '33')
for b in l4:
    print(b)

打印结果：11
         22
         33
eg：for循环元组与列表一致，默认取到的值是元组中的每一个数据值

for循环的执行流程

eg:
先定义一个可迭代对象：列表：l2 = [11, 22, 33, 44, 55]
for i in l2:
     print(l2)

for循环依次将获取到的列表元素（即可迭代对象，也可以是字典、字符串、元组、集合），赋值给变量名i，每循环一次，变量名i就被赋值一次，直到列表中的最后一个元素被获取完毕，循环结束。流程图如下：

for+break语句

break语句可用于结束整个for循环，与while循环一样，当有嵌套循环时，break语句只能跳出最近一层的循环

# eg:打印数字1-10  遇到数字7则结束打印
for i in range(1,11):
    if i == 7:
        break
    print(i)
    
"""
break也能够结束所在的那一层for循环
"""

for+continue语句

continue语句用于结束本层循环，然后执行下一次循环，当有嵌套循环时，continue语句也是只能跳出最近一层的循环，然后继续执行下一次循环

# eg:打印数字1-10  遇到数字7跳过，继续执行下一次循环
for i in range(1, 11):
    if i == 7:
        continue
    print(i)
    
"""
continue也能够结束所在的那一次for循环 直接开始下一次
"""

for+else语句

如果for循环没有被Break语句强制终止，循环体结束后，则会执行else语句下的子代码，否则不执行

for i in range(10):
    print(i)
    if i == 5:
        break
else:
    print('嘿嘿嘿 猜猜我什么时候执行')

range函数的使用方法

range()函数可用于创建一个整数列表，一般出现在for循环中
在python3中，range()函数返回的是一个可迭代的对象(对象是类型)，而不是列表，这样做的目的是为了节省代码所占用的存储空间

range函数语法

range(start, stop[, step])

参数说明：
start: 计数从 start 开始，默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

for i in range(10):
    print(i)      
    
# 从 0 开始到 10   (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# 如果括号内只有一个数字 那么就是从0开始到数字减一结束(顾头不顾尾 左包含右不包含)


for i in range(3, 11):
    print(i)
    
# 从 3 开始到 11   (3, 4, 5, 6, 7, 8, 9, 10)
# 括号内有两个数字 第一个是起始位置(包含) 第二个是终止位置(不含)


for i in range(0, 30, 5):  
    print(i)
    
# 步长为 5         (0, 5, 10, 15, 20, 25)
# 括号内有三个数字 最后一个是数据的间隔数(等差数列)

range()函数在python2和python3中的区别

"""
在python2中有两个
	range()
		直接产生一个列表 当数据量很大的时候可能会造成内存溢出(爆满)
	xrange()
		其实就是python3里面的range方法
		
在python3中只有一个
	range()
		类似于是一个工厂 什么时候要什么时候创建给你 节省内存
"""

Python数据类型的内置方法

数据类型之整型内置方法

在python中，整型是没有内置方法的，它是用于数值计算的，可以用于进行类型转换和进制转换

数据类型转换

我们之前转换数据类型的方式是：将输入的数据类型通过变量名的方式进行赋值，然后通过int进行数据转换，如下：

name = input()
name =int(name)

int可以将由纯数字组成的字符串直接转换成整型，若是包含其它非整数的符号，则会报错

# print(type(int('666')))              # <class 'int'>  字符串内部是纯数字可以进行数据类型转换
# print(type(int('666@1')))                # 存在特殊符号，无法进行数据类型转换，必须是纯数字
# print(type(int('66.66')))               # 存在小数点，无法进行数据类型转换

进制转换

"""
二进制、八进制、十进制、十六进制之间的转换
"""
# print(bin(1000))      # bin() 将十进制转换为二进制         0b是二进制的标识     0b1111101000
# print(oct(1000))      # oct() 将十进制转换为八进制         0o是八进制的标识     0o1750
# print(hex(1000))      # hex() 将十进制转换为十六进制        0x是十六进制的标识    0x3e8

"""
其他进制转十进制
"""

# print(int(0b1111101000))      # 1000      自动转换进制数
# print(int(0o1750))            # 1000      自动转换进制数
# print(int(0x3e8))             # 1000      自动转换进制数

数据类型之浮点型内置方法

在python中，浮点型也是没有内置方法的，只适用于类型转换，并且只能转换数字

  数据类型转换：
  
  # 数据类型转换之浮点型内置方法
  
  # print(float(12138))               # 12138.0
  # print(type(float('12138')))       # <class 'float'>
  # print(type(float('dy12138')))     # 无法进行数值转换，存在字母
  # print(type(float(12138.66)))      # <class 'float'> 浮点型在转换时只能识别一个小数点
  # print(type(float('12138.66.77.88.99.1')))      # 无法转换，直接报错
  
  # 针对布尔值的特殊情况，包含int与float的转换
      print(float(True))    # 1.0
      print(float(False))   # 0.0
      
      print(int(True))      # 1
      print(int(False))     # 0

数据类型之字符串内置方法

字符串可以转换任意类型的数据值，并且拥有很多种内置方法

数据类型转换：可以转换所有的数据值

print(str(777))                                 # 777
print(str(7.7))                                 # 7.7
print(str([9, 9, 9, ]))                         # [9, 9, 9]
print(str({'username': '张三'}))                 # {'username': '张三'}
print(str(True))                                # True
print(str((6, 6, 6)))                           # (6, 6, 6)
print(str({8, 8, 8, 8}))                        # {8}


print(type(str(777)))                           # <class 'str'>
print(type(str(7.7)))                           # <class 'str'>
print(type(str([9, 9, 9, ])))                   # <class 'str'>
print(type(str({'username': '张三'})))           # <class 'str'>
print(type(str(True)))                          # <class 'str'>
print(type(str((6, 6, 6))))                     # <class 'str'>
print(type(str({8, 8, 8, 8})))                  # <class 'str'>

字符串的内置方法

# 数据类型之字符串内置方法
#
# print(str(777))                                 # 777
# print(str(7.7))                                 # 7.7
# print(str([9, 9, 9, ]))                         # [9, 9, 9]
# print(str({'username': '张三'}))                 # {'username': '张三'}
# print(str(True))                                # True
# print(str((6, 6, 6)))                           # (6, 6, 6)
# print(str({8, 8, 8, 8}))                        # {8}
#
#
# print(type(str(777)))                           # <class 'str'>
# print(type(str(7.7)))                           # <class 'str'>
# print(type(str([9, 9, 9, ])))                   # <class 'str'>
# print(type(str({'username': '张三'})))           # <class 'str'>
# print(type(str(True)))                          # <class 'str'>
# print(type(str((6, 6, 6))))                     # <class 'str'>
# print(type(str({8, 8, 8, 8})))                  # <class 'str'>
#
#


# 1.索引取值：单个字符
# s1 = 'my best friends'
# print(s1[1])                  # y

# 2.切片取值：多个字符              # 索引切片的位置默认是从左往右的，如果是负数取值，可以通过参数:来控制
# print(s1[0:4])                # my b 从索引0的位置开始取值，到索引4结束，顾头不顾尾

# 3.支持负数取值
# print(s1[-1])                 # s  -1就是最后一位
# print(s1[-1:-3:-1])           # sd 可以通过第三个参数的+-1来控制方向
# print(s1[-4:-1])              # end

# 4.间隔取值
# print(s1[:])                    # my best friends 取值所有
# print(s1[::2])                  # m etfins 针对整个字符串，隔一个取一个
# print(s1[0:5:1])                  # my be 默认1可以不写
# print(s1[0:5:2])                  # m e

# 5.统计字符串中字符的个数
# print(len(s1))                  # 15 字符串里，空格也算字符

# 6.移除字符串首尾指定的字符
# username = input('username>>>:')
# if username == '张三':
#     print('登录成功')
# else:
#     print('登录失败')

# username = ' lisa '
# print(len(username))  # 6
# print(username.strip(), len(username.strip()))  # lisa 4  strip默认移除字符串首尾的空格
# cd = username.strip()
# print(username, len(username))  # lisa  6  字符串在调用内置方法时，不是改变源数据，而是产生了新的数据
# print(cd, len(cd))              # lisa 4   可以添加一个变量名并进行赋值
# desc1 = '##zhangsan##'
# print(desc1.strip('#'))           # 移除字符串首尾出现的#号
# print(desc1.lstrip('#'))          # 移除字符串左边出现的#号
# print(desc1.rstrip('#'))          # 移除字符串右边出现的#号
# 用户登录优化
# username = input('username>>>:').strip()  # 先获取用户输入，然后立刻移除首尾的空格，最后绑定给变量名username
# if username == 'zs':
#     print('a')
# else:
#     print('b')

# 7.按照指定的字符切割字符串
# info = 'my|hobby|running'
# 当字符串中出现了连续的特征符号|，应该考虑切割
# a = info.split('|')
# print(a, type(a))                # ['my', 'hobby', 'running'] <class 'list'>  split按照指定的字符切割字符串后，结果是一个列表
# aa, bb, cc, = info.split('|')      # 1、针对字符串，按照|切割产生一个列表，2、添加3个变量解压赋值依次获取列表里的数据值
# print(info.split('|', maxsplit=1))   # ['my', 'hobby|running']    从左往右，切割一次
# print(info.rsplit('|', maxsplit=1))  # ['my|hobby', 'running']    从右往左，切割一次

# 8.字符串大小写
# s2 = 'My Name Is Jack 777 Are You Ok'
# print(s2.lower())   # my name is jack 777 are you ok  字母全部转换成小写
# print(s2.upper())   # MY NAME IS JACK 777 ARE YOU OK  字母全部转换成大写
# print(s2.islower())   # False  判断字符串中所有的字母是否全是小写
# print(s2.isupper())   # False  判断字符串中所有的字母是否全是小写
# print('aaa'.islower())  # True
# print('AAA'.isupper())  # True
# code = 'T9UE33R'
# print('这是网页返回的随机验证码:%s' % code)
# xxx_code = input('请输入验证码>>>:')
# if xxx_code.upper() == code.upper():       # 统一转为大写或者小写，再做比对
#     print('ok')
# else:
#     print('no')

# 9.字符串的格式化输出
# 方式一：等价于%s占位，没有什么优势
# info = 'my name is {} my age is {}'
# print(info.format('le', 32))         # my name is le my age is 32
# 方式二：支持索引取值，并且支持重复使用
# info = 'my name is {0} my age is {1}'
# print(info.format('le', 32))           # my name is le my age is 32  同一份数据可以支持多次使用
# 方式三：支持关键字取值，可以看成是按K取值，也支持重复使用
# info = 'my name is {name} my age is {age}'
# print(info.format(name='le', age=23))    # my name is le my age is 23
# 方式四：推荐使用，更加方便，可以重复使用，格式化输出就用这个
# name = 'lla'
# age = 17
# print(f'my name is {name} my age is {age}')          # my name is lla my age is 17

# 10.统计字符串中指定字符出现的次数
# info = 'eeeddfsffgaggafadsfhiaf'
# print(info.count('g'))            # 3 功能类似于for循环 可以是多个字符

# 11.判断字符串的开头或者结尾
# info = 'baby is best'
# print(info.startswith('b'))         # True 判断字符串是不是字母b开头的
# print(info.endswith('t'))           # True 判断字符串是不是字母t结束的

# 12.字符串的替换
# info = 'hua hua wei NB'
# print(info.replace('hua', 'xun'))        # xun xun wei NB  从左往右依次全部把hua替换为wei
# print(info.replace('hua', 'xun', 1))     # xun xun wei NB  从左往右指定个数把hua替换为wei

# 13.字符串的拼接
# info1 = 'hua'
# info2 = 'wei'
# print(info1+info2)          # huawei  字符串支持+号进行拼接  适用于字符串量小
# print(info1 * 5)            # huahuahuahuahua 也支持乘号拼接
# print(''.join(['hua', 'wei', '666']))     # huawei666  字符串join方法拼接  适用于字符串量大
# print('|'.join(['hua', 'wei', '666']))    # hua|wei|666
# print(''.join(['hua', 'wei', 666]))         # 列表中的数据必须全是字符串类型，否则会报错

# 14.判断字符串中是否是纯数字
# print('123'.isdigit())        # True
# print('123a'.isdigit())       # False
# print(''.isdigit())           # False
# age = input('age>>>:')
# # 先判断是不是纯数字
# if age.isdigit():
#     age = int(age)
#     print('ok')
# else:
#     print('你是不是傻')

# 15.查找某个字符对应的索引值
# info = 'hua wei NB'
# print(info.index('i'))           # 6
# print(info.find('i'))            # 6
# index查找索引，如果没有则直接报错
# print(info.index('i', 0, 5))
# find查询索引，如果没有则会返回-1
# print(info.find('i', 0, 5))        # -1

# 16.正文相关操作
# info = 'my name is hony'
# print(info.title())                # My Name Is Hony  将所有的英文首字母大写
# print(info.capitalize())           # My name is hony  将第一个英文的首字母大写

数据类型之列表内置方法

列表数据类型转换，无法转换整数以及小数，其余数据值都可以进行转换

# 数据类型转换：

# print(type([list(999)]))   # 数字无法转换为列表
# print(type(list(999.9)))   # 小数无法转换为列表
# print(type(list('666kong')), list('666kong'))  # <class 'list'> ['6', '6', '6', 'k', 'o', 'n', 'g']  列表
# print(type(list({'name': 'huawei', 'pwd': 666})), list({'name': 'huawei', 'pwd': 666}))   # <class 'list'> ['name', 'pwd']  字典
# 能够被for循环的数据类型都可以转换成列表

# 需要掌握的方法
# l1 = ['huawei', 'alibb', 'ten', 'hengda']
# 1.索引取值
# print(l1[0])                     # huawei  取第一个值
# print(l1[-1])                    # hengda  取最后一个值
# 2.切片操作
# print(l1[0:3])                     # ['huawei', 'alibb', 'ten']  取前3个值
# print(l1[:])                       # ['huawei', 'alibb', 'ten', 'hengda']  取所有的值
# 3.间隔/方向
# print(l1[::2])                     # ['huawei', 'ten'] 隔一个取一个
# 4.统计列表中数据值的个数
# print(len(l1))                     # 4

posted @ 2022-06-27 00:05 dy12138 阅读(57) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 【2022-06-21】Python常见运算符与流程控制

· 【2022-06-17】Python的语法注释与数据类型

· 【2.0】变量、常量和控制语句

· 数据类型交互和流程控制

· Python基础语法

公告

昵称： dy12138
园龄： 2年11个月
粉丝： 18
关注： 22

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

文章分类

linux(1)

dy12138

【2022-06-26】上周内容回顾

本周内容回顾

Python语法注释及变量与常量

Python语法注释

变量与常量的概念

变量的命名规范

变量的命名风格

Python数据类型

数据类型之整型int

数据类型之浮点型float

数据类型之字符串str

数据类型之列表list

数据类型之字典dict

数据类型之布尔值bool

数据类型之元组tuple

数据类型之集合set

用户交互与输出格式化

如何查看数据类型

Python常见运算符与流程控制

基本运算符

赋值符号

逻辑运算符

成员运算符

身份运算符

流程控制简介

流程控制之if分支结构

if+else语句

if+elif+else语句

if嵌套使用

Python流程控制之while循环

循环的定义以及作用

while循环基本使用

while循环的执行流程

while+break语句

while+continue语句

while+else语句

while死循环与全局标志位

Python流程控制之for循环

for循环的定义以及作用

for循环基本使用

for循环的执行流程

for+break语句

for+continue语句

for+else语句

range函数的使用方法

Python数据类型的内置方法

数据类型之整型内置方法

数据类型之浮点型内置方法

数据类型之字符串内置方法

数据类型之列表内置方法

公告

搜索

常用链接

随笔分类

随笔档案

文章分类

阅读排行榜

推荐排行榜