零基础Python全能工程师2022版(第1周~3.2周)

  零基础Python全能工程师2022版

目录：

阶段一： Python基础入门

{01}–第1周环境搭建与基础语法/

{1}--Python环境搭建与脚本结构

{1}--第1章课前指南

Python适合初学者

入门门槛低

简单易学

阶段一：Python基础入门

后端开发部分

Python技能拓展

Python环境搭建

Python的变量

Python的数据类型初体验

学前技术栈之系统操作

Microsoft

如何学习本课程

耐心 恒心 专心 细心 信心

忽略不会的知识，继续向下学习，切勿纠结某一个知识点

反复学习，下一次的学习总会解答上一次的某些疑问，建议至少要学习2～3遍（天才除外）

努力锻炼自己解决问题，比如查看问题原因，网上寻找解决答案；最后手段，依靠他人

{2}--第2章python编程环境搭建

{3}--第3章python脚本的结构

什么是代码执行的入口

赛车要想进入赛道一定有一个入口

程序的执行也需要这么一个入口

代码脚本的写法

假如你叫小明.py，在朋友眼中，你是小明（__name__＝＝＇小明＇）；在你自己眼里，你是你自己（__name__＝＝'__main__＇）

是否一定需要脚本入口

并不是

{4}--第4章变量与关键字

什么是变量

变量的地址在哪

变量名的规则

关键字

什么是关键字

关键字和变量的区别

Python中的常见关键字

什么是关键字

Python内部自带的用于处理业务逻辑的特殊单词

变量名绝不能使用关键字命名

关键字和变量与有何不同  关键字和变量的区别

Python中的常见关键字

init_import.py 

# coding:utf-8

import os

print(os.getcwd())

PS F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建
与脚本结构\{0}--附件\变量与关键字-pythonlearn> python .\init_import.py
F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建与
脚本结构\{0}--附件\变量与关键字-pythonlearn 

keyword.py

# coding:utf-8

name = '小慕'

if __name__ == '__main__':
    print(name)

 PS F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建
与脚本结构\{0}--附件\变量与关键字-pythonlearn> python keyword.py
小慕

main.py

# coding:utf-8

import os


print('我本来就是一级代码块')

if __name__ == '__main__':
    print(os.getcwd())
    print('123')

 PS F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建与脚本结构\{0}--附件\变量与关键字-pythonlearn> python main.py
我本来就是一级代码块 
F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建与脚本结构\{0}--附件\变量与关键字-pythonlearn
123

notes.py

# coding:utf-8

"""
   这个脚本用作注释的练习
   引号注释一般用在两个地方：
    1： 是整个脚本的开篇，作用在于给别人介绍一下这个脚本的作用
    2： 对于函数功能的解释，比如我们的print内置函数里边就有这样的注释
        对于这样的注释，我们未来会在函数篇章给大家介绍
   我们练习一下 # 的注释方法，这种方法也有两种场景，一会儿，我们试试
"""

print('学习python是很有意思的')  # 这是一个简单的注释练习

# 下边的1 2 是一个整体
print('1')
print('2')

PS F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建与脚本结构\{0}--附件\变量与关键字-pythonlearn> python notes.py
学习python是很有意思的
1
2 

print_test.py

# coding: utf-8

print('哈哈')
print('haha')

PS F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建与脚本结构\{0}--附件\变量与关键字-pythonlearn> python print_test.py
哈哈
haha 

struct.py

# coding:utf-8

print('欢迎学习python就业课程')
print('今天的天气非常好')

PS F:\BaiduNetdiskDownload\2024最新版Python教程\零基础  Python全能工程师2022版\{1}--第1周环境搭建与基础语法\{1}--Python环境搭建与脚本结构\{0}--附件\变量与关键字-pythonlearn> python struct.py
欢迎学习python就业课程
今天的天气非常好 

test_input.py

# coding:utf-8

name = input('你的名字是：')
birthday = input('你的生日是：')
like_fruit = input('你喜欢的水果是：')
like_sport = input('你喜欢的运动是：')
like_animal = input('你喜欢的动物是：')

print('你的名字叫做：%s，出生于：%s 年,你喜欢的水果是：%s，最喜欢的运动为：%s，以及最喜欢的小动物是：%s' %
      (name, birthday, like_fruit, like_sport, like_animal))

python test_input.py
你的名字是：wu123
你的生日是：1109 
你喜欢的水果是：苹果
你喜欢的运动是：跑步
你喜欢的动物是：狗
你的名字叫做：wu123，出生于：1109 年,你喜欢的水果是：苹果，最喜欢的运动为：跑步，以及最喜欢的小动物是：狗 

test.py

# coding:utf-8


names_01 = tuple(('dewei', '小慕'))
names_02 = ('dewei', '小慕')
names_03 = ('dewei',)

 python test.py

varable.py

# coding:utf-8


username = '小慕'
age = 20

say_hello = 'hello 小慕'

is_sleep = 'ok'

dog_exists = 'yes'

year_month_day = '2020-02-20'

ymd = '2020-02-20'  # ymd is year_month_day

a, b, c = 1, 2, 3



if __name__ == '__main__':
    print(username)
    print(age)
    print(is_sleep)
    print(dog_exists)
    print(say_hello)
    print(a, b, c)
    print(b)
    print(c)

python varable.py
小慕
20
ok
yes
hello 小慕
1 2 3
2
3 

{2}--Python数据类型

{1}—第1章python数据类型介绍

Python的数据类型

数据类型由来

为什么会有多种数据类型

初次见面-Python中的数据类型

数据类型的由来

控制电脑

为什么会有多种数据类型

为了可以适应更多的使用场景，将数据划分为多种类型，每种类型都有着各自的特点和使用场景，帮助计算机高效的处理与展示数据

初次见面-Python中的数据类型

{2}—第2章数字类型及应用

初识数字类型

整型int

浮点型 float

内置函数--type

整型

整型就是我们说的整数，0也是整数，但是特殊的整数

int 既是整型的代表，又是定义整型的内置函数

定义一个整型，并不一定非要使用int

浮点型

浮点型 就是我们生活中的小数，凡是带有小数点的类型，都可以认为是浮点类型

在python中，float既是浮点型的代表，又是浮点类型定义的内置函数

定义float类型的时候，并不需要一定使用float来声明

内置函数--type

返回变量的类型

type（已经被赋值的变量名或变量）

number.py

数字类型的简单应用

本节课内容

对int与float的简单应用练习---初中生春游，主人公小慕

起因

小慕学校组织春游，他的班级学生共51人，男生28人，女生23人

每人缴费35.5元，并且根据最后使用的情况多退少补

经过

他们早上8点出发，每个大巴可以坐30人，所以需要2辆大巴

上午10点33分到达公园开始游玩

中午12点开始吃饭，伙食费是25.5元

到下午3点05分时集体离开公园，坐大巴回去，来回大巴费用是5元

结果

到晚上5点回到学校，每人退回5元钱

我们的任务

把这一天有关整型，浮点型的信息 按照先后顺序打印出来

定义整型与浮点型，并熟练赋值语句与print，type的使用

number_test.py

# coding:utf-8

title = '小慕学校的春游'

class_count = 51
boys = 28
girls = 23

every_body_pay = 35.5

start_time = 8.00
bus_count = 2
site_every_bus = 30

come_park_time = 10.33

lunch_time = 12.0
lunch_pay = 25.5

leave_park_time = 3.05

bus_pay = 5

come_back_school_time = 5.00

back_pay = 5

if __name__ == '__main__':
    print(title)
    print('小慕的班级有：', class_count)
    print('男生有：', boys)
    print('女生有：', girls)
    print('每人支付', every_body_pay, '元')
    print('出发的时间是早上', start_time, '点')
    print('出行需要', bus_count, '公交大巴')
    print('我们到达公园的时间是：', come_park_time)
    print('吃午饭的时间是：', lunch_time)
    print('每人支付伙食费', lunch_pay)
    print('离开公园的时间是：', leave_park_time)

    print('公交大巴来回的费用是每人', bus_pay)

    print('下午', come_back_school_time, '到达学校')
    print('这一天小慕同学花费了', 30.5)
    print('最后退回', back_pay)
    print(type(come_back_school_time))
    print(type(every_body_pay))
    print(type(site_every_bus))

 python number_test.py

{3}—第3章字符串类型

初识字符串

本节课内容

什么是字符串

字符串的内置函数与定义方法

字符串的重要思想

Python的内置函数id

Python的内置函数len

什么是字符串

用''或""包裹的信息就是字符串

字符串中可以包含任意字符：如字母，数字，符号，且没有先后顺序

字符串的定义方法

在python中，使用str来代表字符串类型，并且通过该函数可以定义字符串

字符串的重要思想

字符串不可改变！

name = 'dewei'

内置函数id

返回变量的内存地址

数字地址＝id（变量）

In [1]: name = 'dewei'

In [2]: id(name)

Out[2]: 4358118128

In [3]: name = 'xiaomu'

In [4]: id(name)

Out[4]: 4358761968

内置函数len

返回字符串的长度

无法返回数字类型的长度，因为数字类型没有长度

返回值 = len(字符串)

length＝ len('python是一门很好的语言')

print(length) 14

count = len(3.14) 报错TypeError: object of type 'float' has no len()

string_test.py

#!/usr/bin/python
# Write Python 3 code in this online editor and run it.
name= 'dewei'
name_02='小慕'
print(id(name))
print(id(name_02))
new_name=name
print(id(new_name)
	  
print(type(name))	
	  
info='''今天天气真好呀'''
print(info)
 
info1 = 'asdf'
info2 = "asdf"

# new_str = 'nihao dewei 'nihao' xiaomu' 报错无效语法
new_str = 'nihao dewei ''nihao'' xiaomu'
print(new_str)
# 或者
# new_str = ''nihao dewei 'nihao' xiaomu''
# print(new_str)

内置成员运算符in的使用

内置成员运算符in的使用

内置函数max

内置函数min

字符串的叠加

成员运算符是用来判断你的数据中是否存在你想要的成员

'开发' in '从零开始一战搞定 python django开发' -＞ True（真）or False（假）

in 左右是一个空格

not in

内置函数 max

max函数返回数据中最大的成员

max（数据）-＞成员值 print（max('今天是1月3日！')) ? 月

内置函数min

min函数返回数据中最小的成员

min（数据）-＞成员值

print（min('今天是1月3日！')) ?  !

中文符号＞字母＞数字＞英文符号

字符串的累加

字符串不是数字不能做减法，乘除法

字符串的拼接，用+这个符号

string_use.py

# coding:utf-8

info = 'python是一个非常有魅力的语言'

result = '魅力' in info
print(result)

result = '语言' not in info
print(result)

info2 = 'python is a good code'

print(max(info2))
print('.', min(info2), '.')

info3 = '天气好 要多锻炼身体。'
info4 = '多锻炼身体 身体换变得更好'

new_str = info3 + info4 + '!'
print(new_str)
print(len(new_str))
length = len(new_str)
print(type(length))

 True
False
y
.   .
天气好 要多锻炼身体。多锻炼身体 身体换变得更好!
25
<class 'int'>

{4}—第4章布尔类型与空类型

布尔类型与空类型

本节课内容

什么是布尔类型，布尔类型的固定值

布尔类型的使用场景

布尔函数的使用

数字，字符串在布尔类型上的应用（内置函数bool）

布尔类型

定义：真假的判断 即 布尔类型

固定值：True-＞真；False-＞假；

布尔值

布尔函数的使用

bool 代表布尔类型 也可以对于结果进行真假的判断

In [1]: res = bool('name' in 'my name is xiaomu')

In [2]:print(res)

True

使用场景

常被用来判断一件事儿的真假

dewei是个男生  √

dewei不喜欢Python ×

数字与字符串的布尔应用

int 0-＞ False，非0-＞True

float 0.0 -＞ False， 非0.0 -＞ True

str ''-＞False（即空字符串），非空字符串-＞ True

在计算机中01是计算机的最原始形态，单个占空间也最小，故而经常会将01用来替代True与 False

Python中的空类型

不属于任何数据类型 就是空类型

固定值：None

空类型属于False的范畴

如果不确定类型的时候 可以使用空类型

bool_and_none.py

# coding:utf-8

test = None
a = 0
b = 1
c = 0.0
d = 0.1
e = ''
f = 'None'
g = None
test = True



if __name__ == '__main__':
    print(bool(a))
    print(bool(b))
    print(bool(c))
    print(bool(d))
    print(bool(e))
    print(bool(f))
    print(bool(g))
    print(test)
    print(type(test))
    print(type(None))

PS D:\Workspace\Python> python ./ex1.py
False
True
False
True
False
True
False
True
<class 'bool'>
<class 'NoneType'>

{5}—第5章列表与元组

本节课内容

什么是列表

列表的定义

列表中的类型

什么是列表

列表就是队列

他是各种数据类型的集合，也是一种数据结构

列表是一种有序，且内容可重复的集合类型

列表的定义

在Python中，list代表着列表这种类型，也可以用它定义一个列表

在Python中，列表中的元素存在于一个[]中

在Python中，列表是一个无限制长度的数据结构

列表中的类型

in，max， min 在列表中的使用

1 in [1,2,3, 4] -> True; 10 in [1,2,3,4] -> False

max([1,2,3,4])-> 4

min([1,2,3,4])->1

max和min在列表中使用的时候，列表中的元素不能是多种类型，如果类型不统一，则会报错

 list_test.py

# coding:utf-8

none_list = [None, None, None]

print(none_list)
print(bool(none_list))
print(len(none_list))
print([])
print(bool([]))

max_list = [1, 3.14]
print(max_list)
print(max(max_list))
print(min(max_list))

id_address = id(max_list)
print(id_address)

 PS D:\Workspace\Python> python .\number_test.py
[None, None, None]
True     
3        
[]       
False    
[1, 3.14]
3.14     
1        
2410035675200

初识元组类型

本节课内容

什么是元组

元组与列表一样，都是一种可以存储多种数据结构的队列

元组也是一个有序的，且元素可以重复的集合

元组的定义

在python中，tuple代表着元组这种类型，也可以用它定义一个元组

在python中，元组中的元素存在于一个()小括号中

列表与元组的区别

元组比列表占用资源更小

列表是可变的，元组是不可变的

元组中的类型

in，max，min 在元组中的使用

1 in (1,2,3, 4) -> True; 10 not in (1,2,3,4) -> True

max((1,2,3,4)) -> 4

min((1,2,3,4)) -> 1

max和min在元组中使用的时候，元组中的元素不能是多种类型，如果类型不统一，则会报错

tuple_test.py

# coding:utf-8

tuple_test = (1, 2, 3)
print(tuple_test)
print(type(tuple_test))

tuple_01 = ()
print(type(tuple_01))

print(bool((1, )))
print(len(tuple_01))

max_count = max(tuple_test)
print(max_count)
min_count = min(tuple_test)
print(min_count)

 PS D:\Workspace\Python> python .\number_test.py
(1, 2, 3)
<class 'tuple'>
<class 'tuple'>
True
0
3
1

{6}-第6章字典

本节课内容

什么是字典

字典的结构与创建方法

字典支持的数据类型

列表与元组中的字典

Python3.7与之前版本 字典的区别

什么是字典

字典是由多个健（key）及其对应的值（value）所组成的一种数据类型

字典的结构与创建方法

在python中，dict用来代表字典，并且可以创建一个字典

在python中，通过{}将一个个key与value 存入字典中

字典支持的数据类型

key支持 字符串，数字和元组类型，但列表是不支持的

value 支持所有python的数据类型

列表与元组中的字典

Python3.7与之前版本 字典的区别

无序

字典的重要特性

字典中每一个key一定是唯一的

dict_test.py

# coding:utf-8

user_info = {'name': '小慕同学', 'age': 10, 'top': '180cm'}

result = 'name' in user_info
print(result)

result = 'hope' in user_info
print(result)
result = 'hope' not in user_info
print(result)

count = len(user_info)
print(count)

result_bool = bool(user_info)
print(result_bool)
empty_dict = {}
print(bool(empty_dict))

 PS D:\Workspace\Python> python .\number_test.py
True
False
True
3
True
False

{7}—第7章数字运算及其应用

数字的运算

本节课内容

赋值运算符有哪些

小练习b kb mb gb的转换

赋值运算符有哪些

operation.py

# coding:utf-8

a = 1
b = 2
c = 3

d = a + b + c
d += c
print(d)  # 9

d -= a
print(d)  # 8

d *= b  # d = d * b
print(d)  # 16

# a /= b
# print(a)

a //= b
print(a)

c %= 3
print(c)

f = 10
f **= 2
print(f)

list_01 = [1, 2, 3]
print(list_01 * 2)
tuple_01 = (1, 2, 3)
print(tuple_01 * 2)
print(tuple_01)

dict_01 = {'name': 'dewei'}

gb = 1
b = gb * 1024 * 1024 * 1024
print(b)

 PS D:\Workspace\Python> python .\number_test.py
9
8
16
0
0
100
[1, 2, 3, 1, 2, 3]
(1, 2, 3, 1, 2, 3)
(1, 2, 3)
1073741824

b kb mb gb的转换

b kb mb gb是计算机的计量单位

字符串与数字的乘法

字符串无法与字符串做乘法

字符串只可以和数字作乘法

本节课内容

比较与身份运算符有哪些

单元存储 就是我们提过的内存块

compare.py

# coding:utf-8

a = 1
b = 2.2
c = 0
d = 18
d_01 = 18
e = -3
f = 300
f_01 = 300

print(a == b)
print(a != b)
print(a < b)
print(a > e)
print(d >= b)
print(d >= d_01)

print(d == d_01)
print(d is d_01)
print('d id is:', id(d))
print('d_01 id is:', id(d_01))

print(f == f_01)
print(f is f_01)

print(f is d)
print(id(f))
print(id(d))

print(f is not d)

 PS D:\Workspace\Python> python .\number_test.py
False
True
True
True
True
True
True
True
d id is: 2220162548496
d_01 id is: 2220162548496
True
True
False
2220163571856
2220162548496
True

{8}—第8章综合案例

one_day_by_xiaomu.py

# coding: utf-8

'''
   小慕早上8点起床，起床之后就开始洗漱
   洗漱完成之后，是8点30分，于是开始吃早饭，早饭有面包，牛奶，还有麦片
   吃完早饭， 上午9点整， 小慕同学开始学习， 他走向自己的书柜， 书柜里有很多书：
     高等数学， 历史，python入门
   小慕拿了python入门的书，开始学习， 一直到12点。
   在12点时候，小慕叫了外卖， 但是到了12点半， 外卖依然没有来。
   于是 小慕给外卖小哥打了电话，电话号码是：
     123456789
   小哥说他有些繁忙，可能要在12点55的时候送达，并请小慕原谅， 他会尽快送到
   到了12点55的时候，外卖小哥准时送达了。
   小慕的午餐是： 西红柿炒鸡蛋盖饭， 价格是 12.5 ，小慕支付了费用后，开始吃饭
   吃过午饭，已经是下午1点25分了，小慕决定不学习了，而是去超市购物。
   于是，小慕来到一家超市，超市里有不同的柜台，放置着不同的内容：
     零食的柜台：
         薯片， 锅巴， 饼干
     生活的柜台：
         洗发水， 香皂， 沐浴乳， 其中洗发水有三款， abc， 价格分别是5，10，15
     水果的柜台：
         苹果，香蕉， 哈密瓜， 橘子， 西瓜
     蔬菜的柜台：
         西红柿， 黄瓜， 韭菜， 大白菜
     饮料的柜台：
         雪碧， 可乐， 矿泉水
   小慕买了 1瓶可乐， 1袋薯片， 两个苹果， 1颗大白菜， 他们的价格分别是：
     2.5， 4， 1.2, 0.9
   小慕还选了 一个洗发水， 并且选择了最贵的一款，放到自己的购物车中
   小慕来到收银台， 收银员计算一下总价 ？
   小慕将这些东西带回家， 然后就去健身了， 在健身之前， 他量了一下体重， 是44.78公斤，
   经过2.5 个小时的锻炼之后， 再来一称， 是 44.76， 小慕很开心， 看来锻炼身体对减肥
   是有帮助的。
   回到家， 已经是下午5点了， 小慕洗了个澡， 拿起可乐 和 一个苹果， 看起了电视，
   一直到很晚...
'''

username = '小慕'
get_up_time = '8:00'
bf_time = '8:30'  # 早餐时间
bf_contents = ['牛奶', '面包', '麦片']
study_time = '9:00'
books = ('高等数学', '历史', 'python入门')
study_book = 'python入门'
ready_lunch_time = '12:00'
brother_phone = 123456789
real_lunch_time = '12:55'
lunch_pay = 12.5
lunch_name = '西红柿鸡蛋盖饭'
shopping_time = '1:25'

shop = {
    'snacks': ['薯片', '锅巴', '饼干'],
    'live': ['洗发水', '香皂', '沐浴乳'],
    'fruits': [
        '苹果', '香蕉',
        '哈密瓜', '橘子',
        '西瓜'
    ],
    'vegetables': ['西红柿', '黄瓜', '韭菜', '大白菜'],
    'drinks': ['雪碧', '可乐', '矿泉水']
}
a, b, c = 5, 10, 15
cola_pay = 2.5
potato = 4
apple_two = 1.2
cabbage = 0.9

tot = cola_pay + potato + apple_two + cabbage + c
sport_time = 2.5
before_weight = 44.78
after_weight = 44.76
go_backhome_time = '5:00'

if __name__ == '__main__':
    print('我们的主人公是:', username)
    print('他是', get_up_time, '起床')
    print(bf_time, '吃早餐')
    print('早餐都有：', bf_contents)
    print(study_time, '开始学习')
    print('书架上都有：', books)
    print(username, '看的书是', study_book)
    print(username, '准备', ready_lunch_time, '吃午饭')
    print('外卖小哥的电话是:', brother_phone)
    print(username, '在', real_lunch_time, '开始吃饭')
    print('他吃的是', lunch_name, '并且价格是', lunch_pay)
    print('购物的时间是', shopping_time)
    print('超市的柜台里有：', shop)
    print(username, '共花费', tot, '元')
    print('去健身了')
    print('健身之前，体重是', before_weight)
    print('经过了', sport_time, '时间的锻炼')
    print('体重变成了', after_weight)
    print(username, '在', go_backhome_time, '回家了')

 PS D:\Workspace\Python> python .\number_test.py
我们的主人公是: 小慕
他是 8:00 起床
8:30 吃早餐
早餐都有： ['牛奶', '面包', '麦片']
9:00 开始学习
书架上都有： ('高等数学', '历史', 'python入门')
小慕 看的书是 python入门
小慕 准备 12:00 吃午饭
外卖小哥的电话是: 123456789
小慕 在 12:55 开始吃饭
他吃的是 西红柿鸡蛋盖饭 并且价格是 12.5
购物的时间是 1:25
超市的柜台里有： {'snacks': ['薯片', '锅巴', '饼干'], 'live': ['洗发水', '香皂', '沐浴乳'], 'fruits': ['苹果', '香蕉', '哈密瓜', '橘子', '西瓜'], 'vegetables': 
['西红柿', '黄瓜', '韭菜', '大白菜'], 'drinks': ['雪碧', '可乐', '矿泉水']}     
小慕 共花费 23.6 元
去健身了
健身之前，体重是 44.78
经过了 2.5 时间的锻炼
体重变成了 44.76
小慕 在 5:00 回家了

{02}–第2周三大主流数据类型的操作/

{1}—Python字符串常用方法

{1}—第1章课程介绍

三大主流数据类型的操作

本周内容

Python的对象

字符串操作以及他的内置函数

列表（元组）的操作以及他的内置函数

字典的操作以及他的内置函数

Python字符串操作与内置函数

列表（元组）操作与内置函数

字典操作与内置函数

{2}-第2章python对象

{3}—第3章字符串函数及其操作

本节课内容

capitalize的功能

capitalize的用法

capitalize的注意事项

capitalize的功能

将字符串的首字母大写，其他字母小写

capitalize的用法

用法：

newstr = string.capitalize()

参数：

函数括弧内什么都不用填写

capitalize的注意事项

只对第一个字母有效

只对字母有效

已经是大写，则无效

capitalize.py

# coding:utf-8

name = 'xiao mu'
info = 'hello 小慕'
_info = '小慕 hello'
number_str = '1314'

new_name = name.capitalize()
new_info = info.capitalize()
_new_info = _info.capitalize()
new_number_str = number_str.capitalize()

print(new_name, name)
print(new_info, info)
print(_new_info)
print(new_number_str)

 PS D:\Workspace\Python> python .\number_test.py
Xiao mu xiao mu
Hello 小慕 hello 小慕
小慕 hello
1314

本节课内容

casefold与lower功能

casefold 与lower 用法

casefold与lower的注意事项

casefold 与lower 的功能

将字符串全体小写

casefold 与lower的用法

用法：

newstr＝ string.casefold（）-＞函数括弧内什么都不用填写

newstr＝ string.lower（）-＞函数括弧内什么都不用填写

casefold与lower的注意事项

只对字符串中的字母有效

已经是小写，则无效

# coding:utf-8

message_en = 'How do you do? Xiaomu'
message_ch = '你好呀, XiaoMu'
message_mix = '你好呀，Xiaomu, 今天是星期3！'

message_en_lower = message_en.lower()
message_en_casefold = message_en.casefold()

message_ch_lower = message_ch.lower()
message_ch_casefold = message_ch.casefold()

message_mix_lower = message_mix.lower()
message_mix_casefold = message_mix.casefold()

print(message_en_lower, message_en_casefold, message_en)
print(message_ch_lower, message_ch_casefold)
print(message_mix_lower, message_mix_casefold)

empty = ''
empty_lower = empty.lower()
empty_casefold = empty.casefold()

print('.' + empty_lower + '.', '.' + empty_casefold + '.')

 PS D:\Workspace\Python> python .\number_test.py
how do you do? xiaomu how do you do? xiaomu How do you do? Xiaomu
你好呀, xiaomu 你好呀, xiaomu
你好呀，xiaomu, 今天是星期3！ 你好呀，xiaomu, 今天是星期3！
.. ..

本节课内容

upper的功能

upper的用法

用法：

big_str = string.upper()

参数：

函数括弧内什么都不用填写

In [9]: big_name = name.upper()

In [10]: print(big_name)

upper的注意事项

只对字符串中的字母有效

已经是大写，则无效

upper.py

# coding:utf-8

info = 'Hello World! Hello XiaoMu'

big_info = info.upper()
small_info = info.lower()

print(big_info)
print(small_info)

PS D:\Workspace\Python> python .\number_test.py
HELLO WORLD! HELLO XIAOMU
hello world! hello xiaomu

本节课内容

swapcase的功能

swapcase的用法

swapcase 的注意事项

swapcase的功能

swapcase的用法

用法：

newstr = string.swapcase()

参数：

函数括弧内什么都不用填写

swapcase的注意事项

只对字符串中的字母有效

swapcase.py

# coding:utf-8

info_one = 'Python Code Is Good'
info_two = 'PYTHON DJANGO FLASK'
info_three = 'python web so easy'

info_one_new = info_one.swapcase()
info_two_new = info_two.swapcase()
info_three_new = info_three.swapcase()

print(info_one_new)
print(info_two_new)
print(info_three_new)

PS D:\Workspace\Python> python .\number_test.py       
HELLO WORLD! HELLO XIAOMU
hello world! hello xiaomu

本节课内容

zfill的功能

zfill的功能

为字符串定义长度，如不满足，缺少的部分用0填补

zfill的用法

用法：

newstr = string.zfill(width)

参数：

width：新字符串希望的宽度

zfill的注意事项

与字符串的字符无关

如果定义长度小于当前字符串长度，则不发生变化

zfill.py

# coding:utf-8

heart = 'love'


if __name__ == '__main__':
    print(' t  ' + heart)
    print('t    ' + heart)
    print(heart.zfill(10))
    print(heart.zfill(9))
    print(heart.zfill(8))
    print(heart.zfill(6))
    print(heart.zfill(4))

  t  love
t    love 
000000love
00000love 
0000love  
00love    
love

本节课内容

startswith和endswith 的功能

startswith和endswith的用法

startswith和endswith功能

startswith 判断字符串开始位是否是某成员（元素）

startswith和endswith用法

endswith 判断字符串结束位是否是某成员（元素）

用法：

string.startswith（item）-＞ item：你想查询匹配的元素，返回一个布尔值

string.endswith（item） -＞ item：你想查询匹配的元素，返回一个布尔值

swith.py

# coding:utf-8

info = 'this is a string example!!'

result = info.startswith('this')
print(result)

result = info.startswith('this is a string example!!')
print(result)

print(bool(info == 'this is a string example!!'))

result = info.endswith('this is a string example!!')
print('result:', result)

PS D:\Workspace\Python> python .\number_test.py
True
True
True
result: True

本节课内容

find和index的功能

find和index的用法

用法：

string.find（item）-＞item：你想查询的元素，返回一个整型

string.index（item）-＞item：你想查询的元素，返回一个整型或者报错

Ps：字符串里的位置是从左向右，以0开始的

find与index的区别

如果find找不到元素，会返回-1

如果index找不到元素，会导致程序报错

find.py

# coding:utf-8

info = 'python is a good code'

result = info.find('a')
print(result)
result = info.find('ok')
print(result)

result = info.index('a')
print(result)

result = info.index('ok')
print(result)

 PS D:\Workspace\Python> python .\number_test.py
10
-1
10
Traceback (most recent call last):
  File "D:\Workspace\Python\number_test.py", line 13, in <module>
    result = info.index('ok')
ValueError: substring not found

本节课内容

strip的功能

strip的用法

strip的拓展知识

strip的用法

用法：

newstr = string.strip(item)

参数：

括弧里需要传一个你想去掉的元素，可不填写

strip的拓展

传入的元素如果不在开头或结尾则无效

Istrip 仅去掉字符串开头的指定元素或空格

rstrip 仅去掉字符串结尾的指定元素或空格

strip.py

# coding:utf-8

info = '    my name is dewei    '
new_info = info.strip()
print('.' + new_info + '.')

info_01 = 'my name is dewei'
new_info_01 = info_01.strip(info_01)
print(new_info_01)
print(len(new_info_01))


new_str = 'abcde'
print(new_str.lstrip('a'))
print(new_str.rstrip('e'))

 PS D:\Workspace\Python> python .\number_test.py
.my name is dewei.

0
bcde
abcd

本节课内容

replace的功能

replace的功能

将字符串中的old（旧元素）替换成new（新元素），并能指定替换的数量

replace的用法

用法：

newstr = string.replace(old, new, max)

参数：

old：被替换的元素，

new：替代old的新元素，

max：可选，代表替换几个，默认全部替换全部匹配的old元素

replace.py

# coding:utf-8

info = ('要从小白到一个有经验的开发者，无论是通过视频还是文字教程学习，你会发现很'
        '少有初级课程就非常贴近实际工作的，作为一个刚入坑的小白通常并不知道需要学'
        '习什么，往往是自认为入门的时候都学习了，到了公司里才发现很多都不会。'
        '我希望做这样一个课程，虽是入门课程，但涉及相关领域的多处知识，让小白在学'
        '习后进入公司岗位不会因为没听过而蒙圈；同时希望这个课也可以帮助非Python工'
        '程师快速转型或者快速转职能')

a = '小白'
b = '一个'
c = '蒙圈'
d = '课程'
e = '*'
f = '0'
g = '$'
o = '@'

test = info.replace(a, e).replace(b, f).replace(c, g).replace(d, o)
print(test)


# test = info.replace(a, e)
# print(test)
# test = test.replace(b, f)
# print(test)
# test = test.replace(c, g)
# test = test.replace(d, o)
# print(test)

 PS D:\Workspace\Python> python .\number_test.py
要从*到0有经验的开发者，无论是通过视频还是文字教程学习，你会发现很少有初级@就非
常贴近实际工作的，作为0刚入坑的*通常并不知道需要学习什么，往往是自认为入门的时候
都学习了，到了公司里才发现很多都不会。我希望做这样0@，虽是入门@，但涉及相关领域 
的多处知识，让*在学习后进入公司岗位不会因为没听过而$；同时希望这个课也可以帮助非
Python工程师快速转型或者快速转职能

本节课内容

isspace

istitle

isupper

isspace

功能：

isspace 判断字符串是否是一个由空格组成的字符串

用法：

booltype＝ string.isspace（）-＞无参数可传，返回一个布尔类型

istitle

功能：

istitle 判断字符串是否是一个标题类型

用法：

booltype ＝String.istitle （）-＞无参数可传，返回一个布尔类型

isupper与islower

功能：

isupper 判断字符串中的字母是否都是大写

islower判断字符串中的字母是否都是小写

用法：

booltype＝ string.isupper（）-＞无参数可传，返回一个布尔类型

booltype＝string.islower（）-＞ 无参数可传，返回一个布尔类型

join和split 稍后见

我们数据类型转换的时候见

str_bool.py

# coding:gbk

title = 'Back Of China'
upper_str = 'PYTHON IS A GOOD CODE 哈哈!'
upper_str_02 = 'Python Is A Good Code'
lower_str = 'i love python 哈哈 !'
not_empty = '!     !'

print(title.istitle())
print(upper_str_02.istitle())

print('isupper', upper_str.isupper())

print('islower', lower_str.islower())

print(not_empty.isspace())

 PS D:\Workspace\Python> python .\number_test.py
True
True
isupper True
islower True
False

{4}—第4章字符串编码格式

本节课内容

什么是编码格式

常见的编码格式

通用的编码格式

什么是编码格式

有一定规则的规则

使用了这种规则，我们就能知道传输的信息是什么意思

常见编码格式

gbk中文编码

ascii英文编码

 通用的编码格式

utf-8是一种国际通用的编码格式

coding.py

# coding: utf-8

name = '小慕'
print(name)
age = 10
heart = 'love'
print(age, heart)

 PS D:\Workspace\Python> python .\number_test.py
小慕
10 love

{5}—第5章字符串格式化

本节课内容

什么是格式化

使用格式化场景和目的

什么是格式化

定义：一个固定的字符串中有部分元素是根据变量的值而改变的字符串

格式化使用场景与目的

发送邮件的时候

发送短信的时候

App上发推送的时候

根据类型定义的格式化

字符串格式化使用操作符％来实现

'my name is %s, my age is %s ' % ('dewei', 33)

format.py

# coding:utf-8

info = 'my name is %s, my age is %s'

name_01 = '小慕'
age_01 = 10
name_02 = 'dewei'
age_02 = 33
print(info % (name_01, age_01))
print(info % (name_02, age_02))

message = '您好， 今天是%s, 您的手机号码：%s 已经欠费了，请尽快充值'
print(message % ('星期一', 123456789))

print(message % (1234567, '星期2'))
print(message)

books = ['python', 'django', 'flask']
info_2 = 'my name is %s, my age is %s, my book is %s'
print(info_2 % (name_01, age_01, books))

dict_01 = {'a': 'a', 'b': 'b'}
print('dict is %s' % dict_01)

info_3 = 'my name is {0}, my age is {1}, my book is {2}'
print(info_3.format(name_02, age_02, books))

info_4 = f'my name is {name_02}, my age is {age_02}'
print(info_4)

print(info_3.format('dewei', 33, ['python']))

PS D:\Workspace\Python> python .\number_test.py
my name is 小慕, my age is 10
my name is dewei, my age is 33
您好， 今天是星期一, 您的手机号码：123456789 已经欠费了，请尽快充值
您好， 今天是1234567, 您的手机号码：星期2 已经欠费了，请尽快充值
您好， 今天是%s, 您的手机号码：%s 已经欠费了，请尽快充值
my name is 小慕, my age is 10, my book is ['python', 'django', 'flask']
dict is {'a': 'a', 'b': 'b'}
my name is dewei, my age is 33, my book is ['python', 'django', 'flask']        
my name is dewei, my age is 33
my name is dewei, my age is 33, my book is ['python']

格式化符号

用于对应各种数据类型的格式化符号-----格式化符号

format2.py

# coding:utf-8

print('%c' % 1020)
# print('%c' % 'ba')
print('%c' % 999999)

print('%u' % -1)
print('%f' % 1.2)
print('%f' % 3.14)
print('%f' % 12)
print('%d' % 10)
print('%d' % -10)
print('%d' % 1.2)
print('%s' % '123')
print('%s' % 123)
# print('%f' % '1.2')

# print('{:d}'.format(1))
# print('{:f}'.format(1.2))
# print('{:s}'.format(12))

print('%o' % 24)
print('%x' % 32)
#print('%x' % '123ab')

number = int('123ab', 16)
print(number)
print('%x' % number)

print('%e' % 1.2)

PS D:\Workspace\Python> python .\number_test.py
ϼ
󴈿
-1
1.200000
3.140000
12.000000
10
-10
1
123
123
30
20
74667
123ab
1.200000e+00 

格式化符号

{6}—第6章字符串的特殊字符

本节课内容

什么是转义字符

Python中的转义字符们

转义无效符

什么是转义字符

字符要转成其他含义的功能，所以我们叫他转义字符

＼＋字符

Python中的转义字符们

format3.py

# coding:utf-8

info_n = ('my name \nis %s\n' % 'dewei')
print(info_n)

info_t = 'my name \tis dewei'
print(info_t)

info_v = 'my name \vis dewei'
print(info_v)

info_a = 'my name \ais dewei'
print(info_a)

info_b = 'my name is dewei\b'
print(info_b)

info_r = 'my name is dewei\r'
print(1, info_r, info_b)

info_f = 'my name is dewei\f'
print('f', info_f)

print('my name is \'dewei\'')
print("my name is \"Dewei\"")

print('my name is \\ dewei')

print(r'my name is \\ dewei\n')

PS D:\Workspace\Python> python .\number_test.py
my name 
is dewei

my name         is dewei
my name 
        is dewei
my name is dewei
my name is dewei
 my name is deweii
f my name is dewei

my name is 'dewei'
my name is "Dewei"
my name is \ dewei
my name is \\ dewei\n

转义无效符

在python中在字符串前加r来将当前字符串的转义字符无效化

{2}—Python列表常用方法

{1}—第1章初识列表操作符

列表元组的操作符

本节课内容

len 在列表与元组上的使用

列表（元组）之间的累加与乘法

in和not in 在列表（元组）中的用法

len在列表元组中的使用

len函数可以计算出除了数字类型以外，其他所有数据类型的长度

列表（元组）之间的累加与乘法

in 和 not in 在列表（ 元组）中的用法

in是判断 某个成员（元素）是否在该数据结构中

not in 就是判断某个成员（元素）是否不在该数据结构中

list_01.py

#coding:utf-8

names = ('dewei', 'xiaomu', 'xiaowang')

names_add = names + names
names_c = names * 10

print(names_add)
print(names_c)
print('names_c length is', len(names_c))

names += ('abc', )
print(names)
names *= 10
print(names)

names_list = ['dewei', 'xiaomu']
names_list += ['xiaowang']
print(names_list)
names_list *= 5
print(names_list)

print('dewei' in names_list)
print('dewei' not in names_list)

 PS D:\Workspace\Python> python .\number_test.py
('dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang')
('dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang')
names_c length is 30
('dewei', 'xiaomu', 'xiaowang', 'abc')
('dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc', 'dewei', 'xiaomu', 'xiaowang', 'abc')
['dewei', 'xiaomu', 'xiaowang']
['dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang', 'dewei', 'xiaomu', 'xiaowang']
True
False

{2}—第2章列表函数的操作

本节课内容

append的功能

append的用法

用法：

list.append(new_item)

参数：

new＿item：添加进列表的新的元素（成员）

append的注意事项

被添加的元素只会被添加到末尾

append函数是在原有列表的基础上添加，不需要额外添加新的变量

list_appemd.py

# coding:utf-8

books = []
print(id(books))
books.append('python入门课程')
print(books)
print(id(books))

number = 1.1
tuple_test = (1, )
dict_test = {'name': 'dewei'}

books.append(number)
books.append('django')
books.append(1)

print(books)
print(id(books))

 PS D:\Workspace\Python> python .\number_test.py
1386405511104
['python入门课程']
1386405511104
['python入门课程', 1.1, 'django', 1]
1386405511104

本节课内容

insert的功能

insert的用法

用法：

list.insert(index, new_item)

参数：

index：新的元素放在哪个位置（数字）

new＿item：添加的新元素（成员）

insert的用法

insert与append的区别

append只能添加到列表的结尾，而insert可以选择任何一个位置

如果insert传入的位置列表中不存在，则将新元素添加到列表结尾

字符串，元组，列表元素的位置是从0开始计算的

list_insert.py

# coding:utf-8

students = [
    {'name': 'dewei', 'age': 33, 'sex': '男', 'id': 1, 'top': '174'},
    {'name': '小慕', 'age': 10, 'sex': '男', 'id': 2, 'top': '175'}
]

xiaoyun = {
    'name': 'xiaoyun',
    'age': 18,
    'sex': '女',
    'id': 3,
    'top': '160'
}

students.insert(0, xiaoyun)
print(students)

xiaogao = {
    'name': 'xiaogao',
    'age': 18,
    'sex': '男',
    'id': 4,
    'top': '188'
}
students.insert(3, None)
students.insert(4, None)
students.insert(5, None)

students.insert(6, xiaogao)
print(students)

xiaoming = {
    'name': 'xiaoming',
    'age': 19,
    'sex': '男',
    'id': 5,
    'top': '178'
}

students.insert(3, xiaoming)
print(students)

 PS D:\Workspace\Python> python .\number_test.py
[{'name': 'xiaoyun', 'age': 18, 'sex': '女', 'id': 3, 'top': '160'}, {'name': 'dewei', 'age': 33, 'sex': '男', 'id': 1, 'top': '174'}, {'name': '小慕', 'age': 10, 'sex': '男', 'id': 2, 'top': '175'}]
[{'name': 'xiaoyun', 'age': 18, 'sex': '女', 'id': 3, 'top': '160'}, {'name': 'dewei', 'age': 33, 'sex': '男', 'id': 1, 'top': '174'}, {'name': '小慕', 'age': 10, 'sex': '男', 'id': 2, 'top': '175'}, None, None, None, {'name': 'xiaogao', 'age': 18, 'sex': '男', 'id': 4, 'top': '188'}]
[{'name': 'xiaoyun', 'age': 18, 'sex': '女', 'id': 3, 'top': '160'}, {'name': 'dewei', 'age': 33, 'sex': '男', 'id': 1, 'top': '174'}, {'name': '小慕', 'age': 10, 'sex': '男', 'id': 2, 'top': '175'}, {'name': 'xiaoming', 'age': 19, 
'sex': '男', 'id': 5, 'top': '178'}, None, None, None, {'name': 'xiaogao', 'age': 18, 'sex': '男', 'id': 4, 'top': '188'}]

列表（元组）的count函数

本节课内容

count的功能

返回当前列表中某个成员的个数

count的用法

count的注意事项

如果查询的成员（元素）不存在，则返回0

列表只会检查完整元素是否存在需要计算的内容

list_count.py

# coding:utf-8

animals = ['小猫', '小狗', '龙猫', '小猫', '鹦鹉', '小狗', '小兔子', '小猫']

cat = animals.count('小猫')
dog = animals.count('小狗')
l_cat = animals.count('龙猫')
rabbit = animals.count('小兔子')

print('我家的院子里有很多小动物')
print('其中小猫有 %s 只' % cat)
print('小狗有 {} 只'.format(dog))
print(f'龙猫有 {l_cat} 只')
print('小兔子有 %d 只' % rabbit)
print('我们没有小松鼠， 所以松鼠有  %s 只' % animals.count('松鼠'))

animals_dict = [
    {'name': 'dog'},
    {'name': 'dog'},
    {'name': 'cat'}
]

dog_dict_count = animals_dict.count({'name': 'dog'})
print('小狗在动物的字典中有%s只' % dog_dict_count)

animals_tuple = ('小猫', '小狗', '龙猫', '小猫',
           '鹦鹉', '小狗', '小兔子', '小猫')

cat = animals_tuple.count('小猫')
dog = animals_tuple.count('小狗')
l_cat = animals_tuple.count('龙猫')
rabbit = animals_tuple.count('小兔子')

print('其中小猫有 %s 只\n小狗有 %s 只\n龙猫有 %s 只\n小兔子有%s只'
      % (cat, dog, l_cat, rabbit))

 PS D:\Workspace\Python> python .\number_test.py
我家的院子里有很多小动物
其中小猫有 3 只
小狗有 2 只
龙猫有 1 只
小兔子有 1 只
我们没有小松鼠， 所以松鼠有  0 只
小狗在动物的字典中有2只
其中小猫有 3 只
小狗有 2 只
龙猫有 1 只
小兔子有1只

本节课内容

remove的功能

remove的用法

remove的注意事项

Python内置函数 del

remove用法

用法：

list.remove(item)

参数：

item：准备删除的列表元素

remove的注意事项

如果删除的成员（元素）不存在，会直接报错

如果被删除的元素有多个，只会删除第一个

remove函数不会返回一个新的列表，而是在原先的列表中对元素进行删除

Python的内置函数 del

del 把变量完全删除

list_remove.py

# coding:utf-8

shops = ['可乐', '洗发水', '可乐', '牛奶', '牛奶', '牙膏', '牙膏']

print('我们的超市有这些内容:%s' % shops)
print('我们的可乐有%s件产品' % shops.count('可乐'))
print('我们的牛奶有%s件产品' % shops.count('牛奶'))
print('我们的牙膏有%s件产品' % shops.count('牙膏'))
print('我们的洗发水有%s件产品' % shops.count('洗发水'))
print('我们要购买一件洗发水')
shops.remove('洗发水')
print('现在我们的洗发水还剩下%s件, 当前已经没有洗发水了' % shops.count('洗发水'))
shops.remove('可乐')
print('当前可乐还有%s' % shops.count('可乐'))
shops.remove('可乐')
print('可乐还有%s件' % shops.count('可乐'))

del shops

print(shops)

 PS D:\Workspace\Python> python .\number_test.py
我们的超市有这些内容:['可乐', '洗发水', '可乐', '牛奶', '牛奶', '牙膏', '牙膏']
我们的可乐有2件产品
我们的牛奶有2件产品
我们的牙膏有2件产品
我们的洗发水有1件产品
我们要购买一件洗发水
现在我们的洗发水还剩下0件, 当前已经没有洗发水了
当前可乐还有1
可乐还有0件
Traceback (most recent call last):
  File "D:\Workspace\Python\number_test.py", line 20, in <module>
    print(shops)
NameError: name 'shops' is not defined

本节课内容

reverse的功能

对当前列表顺序进行反转

reverse的用法

用法：

list.reverse()

参数：

无参数传递

list_reverse.py

# coding:utf-8


students = [
    {'name': 'dewei', 'age': 33, 'top': 174},
    {'name': '小慕', 'age': 10, 'top': 175},
    {'name': 'xiaogao', 'age': 18, 'top': 188},
    {'name': 'xiaoyun', 'age': 18, 'top': 165}
]

print('当前的同学顺序是{}'.format(students))
students.reverse()
print('座位更换之后的顺序是{}'.format(students))

 PS D:\Workspace\Python> python .\number_test.py
当前的同学顺序是[{'name': 'dewei', 'age': 33, 'top': 174}, {'name': '小慕', 'age': 10, 'top': 175}, {'name': 'xiaogao', 'age': 18, 'top': 188}, {'name': 'xiaoyun', 'age': 18, 'top': 165}]
座位更换之后的顺序是[{'name': 'xiaoyun', 'age': 18, 'top': 165}, {'name': 'xiaogao', 'age': 18, 'top': 188}, {'name': '小慕', 'age': 10, 'top': 175}, {'name': 'dewei', 'age': 33, 'top': 174}]

本节课内容

sort的功能

对当前列表顺序按照一定规律进行排序

sort的用法

用法：

list.sort(cmp=None, key=None, reverse=False)

参数：

cmp--可选参数，制定排序方案的函数

key-参数比较

reverse--排序规则，reverse=True降序，reverse＝False升序（默认）

cmp与key涉及函数学习，我们在日后讲解当前默认不传即可

sort的注意事项

列表中的元素类型必须相同，否则无法排序（报错）

list_sort.py

# coding:utf-8

shu = '01老鼠'
niu = '02牛'
hu = '03老虎'
tu = '04兔'
long = '05龙'
she = '06蛇'
ma = '07马'
yang = '08羊'
hou = '09猴'
ji = '10鸡'
gou = '11狗'
zhu = '12猪'

shengxiao = []
shengxiao.append(gou)
shengxiao.append(ji)
shengxiao.append(zhu)
shengxiao.append(she)
shengxiao.append(tu)
shengxiao.append(hou)
shengxiao.append(hu)
shengxiao.append(niu)
shengxiao.append(shu)
shengxiao.append(long)
shengxiao.append(ma)
shengxiao.append(yang)

print(shengxiao)
print(len(shengxiao))
shengxiao.sort()
print(shengxiao)
shengxiao.sort(reverse=True)
print(shengxiao)
shengxiao.sort(reverse=True)
print(shengxiao)


mix = ['python', 1.2, {'name': 'dewei'}]

 PS D:\Workspace\Python> python .\number_test.py
['11狗', '10鸡', '12猪', '06蛇', '04兔', '09猴', '03老虎', '02牛', '01老鼠', '05龙', '07马', '08羊']
12
['01老鼠', '02牛', '03老虎', '04兔', '05龙', '06蛇', '07马', '08羊', '09猴', '10鸡', '11狗', '12猪']
['12猪', '11狗', '10鸡', '09猴', '08羊', '07马', '06蛇', '05龙', '04兔', '03老虎', '02牛', '01老鼠']
['12猪', '11狗', '10鸡', '09猴', '08羊', '07马', '06蛇', '05龙', '04兔', '03老虎', '02牛', '01老鼠']

本节课内容

clear的功能

将当前列表中的数据清空

用法：

list.clear（）-＞该函数无参数，无返回值

list_clear.py

# coding:utf-8

mixs = ['python', 1, (1,), {'name': 'dewei'}]
print(mixs, len(mixs))
mixs.clear()
print(mixs, len(mixs))

mixs = []

 PS D:\Workspace\Python> python .\number_test.py
['python', 1, (1,), {'name': 'dewei'}] 4
[] 0

本节课内容

copy的功能

copy的用法

copy与2次赋值的区别

将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同

copy用法

用法：

list.copy（）-＞该函数无参数，返回一个一模一样的列表

old_list=['a', 'b', 'c']

In [53]: new_list = old_list.copy()

In [54]: print(new_list)

['a', 'b', 'c']

copy与二次赋值的区别

a=[1,2,3]

b=a

二次赋值的变量与原始变量享有相同内存空间

copy函数创建的新列表与原始列表不是一个内存空间，不同享数据变更

copy属于浅拷贝

浅拷贝

通俗的说，我们有一个列表a，列表里的元素还是列表，当我们拷贝出新列表b后，无论是a还是b的内部的列表中的数据发生了变化后，相互之间都会受到影响，-浅拷贝

深拷贝

不仅对第一层数据进行了copy，对深层的数据也进行copy，原始变量和新变量完完全全不共享数据-深拷贝

# coding:utf-8

old_list = ['python', 'django', 'flask']

new_list = old_list
new_list.append('tornado')

print(new_list)
print(old_list)
print(id(new_list), id(old_list))

old_list.remove('tornado')
print(new_list, old_list)

del new_list
print(old_list)


old_list_copy = ['python', 'django', 'flask']
new_list_copy = old_list_copy.copy()

print(old_list_copy, new_list_copy)
new_list_copy.append('tornado_copy')
print(old_list_copy, new_list_copy)
print(id(old_list_copy), id(new_list_copy))

PS D:\Workspace\Python> python number_test.py
['python', 'django', 'flask', 'tornado']
['python', 'django', 'flask', 'tornado']
3147867174208 3147867174208
['python', 'django', 'flask'] ['python', 'django', 'flask']
['python', 'django', 'flask']
['python', 'django', 'flask'] ['python', 'django', 'flask']
['python', 'django', 'flask'] ['python', 'django', 'flask', 'tornado_copy']
3147867465344 3147867127488

extend的功能

将其他列表或元组中的元素倒入到当前列表中

用法：

list.extend(iterable) ->

参数：

iterable 代表列表或元组，该函数无返回值

# coding:utf-8

manhua = []
history = []
code = []

new_manhua = ('a', 'b', 'c')
new_history = ('中国历史', '日本历史', '韩国历史')
new_code = ('python', 'django', 'flask')

manhua.extend(new_manhua)
history.extend(new_history)
code.extend(new_code)

print(manhua, history, code)

history.extend(manhua)
del manhua
print(history)

test = []
test.extend(True)
print(test)

PS D:\Workspace\Python> python number_test.py
['a', 'b', 'c'] ['中国历史', '日本历史', '韩国历史'] ['python', 'django', 'flask']
['中国历史', '日本历史', '韩国历史', 'a', 'b', 'c']
Traceback (most recent call last):
  File "D:\Workspace\Python\number_test.py", line 22, in <module>
    test.extend(True)
TypeError: 'bool' object is not iterable 

{3}—第3章列表的索引

什么是索引

什么是切片

列表的索引，获取与修改

通过pop 删除索引

通过del 删除索引

索引在元组中的特殊性

什么是索引

字符串，列表和元组

从最左边记录的位置就是索引

索引用数字表示，起始从0开始

字符串，列表（元组）的最大索引是他们的长度-1

什么是切片

索引用来对单个元素进行访问，切片则对一定范围内的元素进行访问

切片通过冒号在中括号内把相隔的两个索引查找出来［0：10］

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

print(numbers[3: 8])

>>[4,5,6,7,8]

切片规则为：左含，右不含

# coding:utf-8

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(len(numbers) - 1)
print(numbers[9])
print(id(numbers))
print('获取列表完整数据：', numbers[:])
print('另一种获取完整列表的方法：', numbers[0:])
print('第三种获取列表的方法：', numbers[0:-1])
print('列表的反序:', numbers[::-1])
print('列表的反项获取', numbers[-3:-1])
print('步长获取切片:', numbers[0: 8: 2])
print('切片生成空列表', numbers[0: 0])
new_numbers = numbers[: 4]
print(new_numbers)

numbers[3] = 'code'
print(numbers)
numbers[2: 5] = ['a', 'b', 'c']
print(numbers)

item = numbers.pop(4)
print(item, numbers, len(numbers))

del numbers[4]
print(numbers)

tuple_test = (1, 2 ,3)
del tuple_test

PS D:\Workspace\Python> python number_test.py
9
10
1499068708160
获取列表完整数据： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
另一种获取完整列表的方法： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
第三种获取列表的方法： [1, 2, 3, 4, 5, 6, 7, 8, 9]
列表的反序: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
列表的反项获取 [8, 9]
步长获取切片: [1, 3, 5, 7]
切片生成空列表 []
[1, 2, 3, 4]
[1, 2, 3, 'code', 5, 6, 7, 8, 9, 10]
[1, 2, 'a', 'b', 'c', 6, 7, 8, 9, 10]
c [1, 2, 'a', 'b', 6, 7, 8, 9, 10] 9
[1, 2, 'a', 'b', 7, 8, 9, 10] 

{4}—第4章列表之字符串切片

字符串的索引，获取

字符串的find与index函数

字符串的索引，获取

name = 'dewei'

name[0]->d

name[:2] -> de

索引规则与列表相同

切片和索引的获取与列表相同

无法通过索引修改与删除

字符串不可修改

字符串的find与index函数

功能：

获取元素的索引位置

用法：

string.index（item）-＞ item：查询个数的元素，返回索引位置

string.find（item）-＞ item：查询个数的元素，返回索引位置

find与index的区别

find如果获取不到，返回-1

index如果获取不到，直接报错

# coding:utf-8

name = 'dewei'
new_name = name[::-1]
print(new_name)

print(new_name)
result = new_name.index('wei')
print(result)

 PS D:\Workspace\Python> python number_test.py
iewed
iewed
Traceback (most recent call last):
  File "D:\Workspace\Python\number_test.py", line 8, in <module>
    result = new_name.index('wei')
ValueError: substring not found

{3}—Python字典常用方法

{1}—第1章字典的处理

keys功能

用法：

dict.keys（）-＞无需传参，返回一个key集合的伪列表

# coding:utf-8

project = {'id': 1, 'project_name': 'ipad', 'price': 2200, 'count': 30}

project_title = list(project.keys())
print(project_title)
print(type(project_title))

print(project_title[0])
print(project_title[3])
print(project_title[2: 6])
project_title.append('user')
print(project_title)

 PS D:\Workspace\Python> python number_test.py
['id', 'project_name', 'price', 'count']
<class 'list'>
id
count
['price', 'count']
['id', 'project_name', 'price', 'count', 'user']

{2}—第2章获取字典的key与value

［］的获取方法

In [17]: my_dict = {'name': 'dewei', 'age': 33}

In [18]: name = my_dict['name']

In [19]: print(name)

dewei

字典＋中括号内传key，不进行赋值操作 即为获取

返回key对应的value值

get功能

获取当前字典中指定key的value

用法：

dict.get(key,default=None)

参数：

key：需要获取value的key

default：key不存在则返回此默认值，默认是None，我们也可以自定义

［］与get的区别

［］如果获取的key不存在，则直接报错

get如果获取的key不存在，则返回默认值

所以开发中，优先使用get函数

#coding:utf-8

user_info = {
    'id': 1,
    'username': 'dewei',
    'password': 'abcdefg',
    'created_time': '2020-01-01 11:11:11',
    'birthday': None
}

values = []
id = user_info['id']

values.append(id)
values.append(user_info['username'])
values.append(user_info['password'])
#values.append(user_info['created_time'])
values.append(user_info.get('created_time', '2020-02-02'))
# values.append(user_info['birthday'])
values.append(user_info.get('birthday', '2020-03-03'))

print(values)
# values.append(user_info['birthday'])

# values.append(user_info.get('birthday', '1986-01-01'))
# print(values)

PS D:\Workspace\Python> python number_test.py
['id', 'project_name', 'price', 'count']
<class 'list'>
id
count
['price', 'count']
['id', 'project_name', 'price', 'count', 'user']
PS D:\Workspace\Python> python number_test.py
[1, 'dewei', 'abcdefg', '2020-01-01 11:11:11', None] 

{3}—第3章字典的删除与复制操作

clear函数的功能与用法

pop函数的功能与用法

del在字典中的用法

clear功能

clear用法

用法：

dict.clear（）-＞无参数，无返回值

pop功能

删除字典中指定的key，并将其结果

返回，如果key不存在则报错

pop用法

用法：

dict.pop（key）--key 希望被删掉的键

＞＞返回这个key对应的值（value）

del 在字典中的用法 

my_dict = {'name': 'dewei', 'age': 33}

del my_dict['name']

print(my_dict)

>> {'age': 33}

del my_dict

print（my_dict）-＞报错，整个字典对象已被删除

# coding:utf-8

projects = {
    'ipad': {'name': 'ipad', 'price': 2200, 'desc': '平板电脑'},
    'iphone': {'name': 'iphone', 'price': 3000, 'desc': '智能手机'},
    'pc': {'name': 'pc', 'price': 5000, 'desc': '台式电脑'},
    'mac': {'name': 'mac', 'price': 8000, 'desc': '平板电脑'}
}

print(projects.keys())

print('一个中学生购买了{}, 价格是{}'.format(projects['pc']['name'], projects['pc']['price']))
projects.pop('pc')
print(projects.keys())

result = projects.pop('mac')
print('一个程序员购买了{}, 它的价格是{}'.format(result['name'], result.get('price')))
print(projects.keys())

print('{} 和 {} 都被卖出了， 他们一共花费了{}元'.format(
    projects['ipad']['name'], projects['iphone']['name'],
    projects['ipad']['price'] + projects['iphone']['price']
))
projects.clear()
print(projects.keys())

del projects
print(projects)

PS D:\Workspace\Python> python number_test.py
dict_keys(['ipad', 'iphone', 'pc', 'mac'])
一个中学生购买了pc, 价格是5000
dict_keys(['ipad', 'iphone', 'mac'])
一个程序员购买了mac, 它的价格是8000
dict_keys(['ipad', 'iphone'])
ipad 和 iphone 都被卖出了， 他们一共花费了5200元
dict_keys([])
Traceback (most recent call last):
  File "D:\Workspace\Python\number_test.py", line 28, in <module>
    print(projects)
NameError: name 'projects' is not defined. Did you mean: 'property'? 

copy的功能

将当前字典复制一个新的字典

copy的用法

用法：

dict.copy（）-＞该函数无参数，返回一个一模一样的内存地址不同的字典

# coding:utf-8

fruits = {
    'apple': 30,
    'banana': 50,
    'pear': 100
}

real_fruits = fruits.copy()
print(real_fruits)

real_fruits['orange'] = 50
real_fruits.update({'cherry': 100})

print(real_fruits)
real_fruits['apple'] = real_fruits['apple'] - 5
print(real_fruits)
real_fruits['pear'] -= 3
print(real_fruits)

real_fruits.clear()
print(real_fruits)
print('第二天...')
real_fruits = fruits.copy()
print(real_fruits)

PS D:\Workspace\Python> python number_test.py
{'apple': 30, 'banana': 50, 'pear': 100}
{'apple': 30, 'banana': 50, 'pear': 100, 'orange': 50, 'cherry': 100}
{'apple': 25, 'banana': 50, 'pear': 100, 'orange': 50, 'cherry': 100}
{'apple': 25, 'banana': 50, 'pear': 97, 'orange': 50, 'cherry': 100}
{}
第二天...
{'apple': 30, 'banana': 50, 'pear': 100}

{4}—第4章字典成员运算符

字典成员运算符

成员运算符可以用来判断某个键是某个否在字典中。

in	判断某个键是否在字典中，在则返回True，不在则返回False
not in	判断某个键是否不在字典中，不在则返回True，在则返回False

# coding:utf-8

default_dict = {'a': None, 'b': 1, 'c': 0, 'd': ''}

print('a' in default_dict)
print(bool(default_dict['a']))
print(bool(default_dict.get('a')))
print(bool(default_dict.get('b')))
print('f' in default_dict)
print('f' not in default_dict)

{5}--第5章字典popitem

popitem的功能

函数popitem可以删除字典中最后一个元素，并返回由这个元素的键和值组成的二元组。

popitem的用法

该函数的注意事项

popitem的用法

用法：

dict.popitem（）-- 无需传参

＞＞返回被删除的键值对，用元组包裹0索引是key，1索引是value

# coding:utf-8

students = {'dewei': '到', 'xiaomu': '在', 'xiaoyun': '在呢', 'xiaogao': '在'}

print('xiaogao 在吗')
xiaogao = students.popitem()
print('{} 喊 {}'.format(xiaogao[0], xiaogao[1]))
print('xiaoyun 在吗')
xiaoyun = students.popitem()
print('{} 喊 {}'.format(xiaoyun[0], xiaoyun[1]))
print('xiaomu 在吗')
xiaomu = students.popitem()
print('{} 喊 {}'.format(xiaomu[0], xiaomu[1]))
print('dewei在吗')
dewei = students.popitem()
print('{} 喊 {}'.format(dewei[0], dewei[1]))
print(students)
students.popitem()

PS D:\Workspace\Python> python number_test.py
xiaogao 在吗
xiaogao 喊 在
xiaoyun 在吗
xiaoyun 喊 在呢
xiaomu 在吗
xiaomu 喊 在
dewei在吗
dewei 喊 到
{}
Traceback (most recent call last):
  File "D:\Workspace\Python\number_test.py", line 18, in <module>
    students.popitem()
KeyError: 'popitem(): dictionary is empty' 

内置函数update

        我们给update函数传入一个字典dict_，它会把dict_中的元素更新到当前字典中。如果dict_中的键和当前字典中的键有相同的情况，则把dict_中的值更新到当前字典。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '小明'}
dict1.update(dict2)
print(dict1)  # {'name': '小明', 'number': 49, 'sex': '男'}

dict_中存在当前字典中不存在的键时，给当前字典新增元素。

dict1 = {'name': '爆笑蛙', 'number': 49, 'sex': '男'}
dict2 = {'name': '小明', 'hello': 123, 1: 'haha'}
dict1.update(dict2)
print(dict1)  # {'name': '小明', 'number': 49, 'sex': '男', 'hello': 123, 1: 'haha'}

内置函数values

        函数values会返回当前字典的值视图对象，这个值视图对象中的内容是一个列表。列表中的每一个元素，是字典中每一个元素的值。值视图对象是可迭代的，list函数可以把值视图对象中的列表提取出来，也可以使用for循环来迭代。

{6}—第6章所有数据类型与布尔值的关系

所有数据类型与布尔值的关系

字符串，数字，列表，元组，字典，

空类型与布尔值的关系总结

每一种数据类型，自身的值都有表示True与False

# coding:utf-8

a_1 = 1
a_2 = 0

print(bool(a_1))
print(bool(a_2))

print(bool(not a_1))
print(bool(not a_2))

b_1 = '1'
b_2 = ''
print('-------')
print(bool(b_1))
print(bool(b_2))
print(bool(not b_1))
print(bool(not b_2))

c_1 = True
c_2 = False
print('------')
print(c_1)
print(c_2)

print(not c_1)
print(not c_2)

PS D:\Workspace\Python> python number_test.py
True
False
False
True
-------
True
False
False
True
------
True
False
False
True  

{03}–第3周Python流程控制与函数/

{1}--Python集合常用方法

{1}--第1章课程介绍

Python流程控制与函数

本周内容

集合的操作

数据类型间的转换

条件语句

循环

函数

  

(2}--第2章集合的定义

什么是集合

集合与列表的区别

集合的创建方法

set_init.py

# coding:utf-8

a = set()
print(a)
print(type(a))

b = set(['python', 'django', 'flask'])
print(b)

c = {(1,2,3), '123', 1}
print(c)

d = {}
print(d, type(d))

a_list = ['python', 'django', 'python', 'flask']
b_set = set(a_list)
print(b_set)

(3}--第3章集合的增删改查

集合的add函数

集合的update函数

集合的remove函数

集合的clear函数

用del删除集合

add的用法

用法：

set.add(item)

参数：

item：要添加到集合中的元素

返回值：

无返回值

# coding:utf-8

a_list = ['python', 'django', 'django', 'flask']

a_set = set()

a_set.add(a_list[0])
a_set.add(a_list[1])
a_set.add(a_list[2])
a_set.add(a_list[-1])
print(a_set)

a_set.add(True)
a_set.add(None)
print(a_set)

a_tuple = ('a', 'b', 'c')
a_set.update(a_tuple)
print(a_set)
a_set.update('python')
print(a_set)

a_set.remove('python')
print(a_set)

a_set.clear()
print(a_set)

a_set.remove('flask')

 update的功能

update的用法 

用法：

set.update(iterable)

参数：

iterable：集合，列表元组字符串

返回值：

无返回值，直接作用于原集合

remove的功能

remove的用法

用法：

set.remove（item）＃ 注意是元素不是索引

参数：

item：当前集合中的一个元素

返回值：

无返回值，直接作用于原集合

clear的功能

clear的用法

用法：

set.clear()

参数：

无

返回值：

无返回值，直接作用于原集合

del.删除集合

重要说明

集合无法通过索引获取元素

集合无获取元素的任何方法

集合只是用来处理列表或元组的一种临时类型，他不适合存储与传输

{4}--第4章获取两个集合操作的函数

什么是差集

difference的功能

difference的用法

用法：

a_set.difference(b_set)

参数：

：当前集合需要对比的集合

返回值：

返回原始集合于对比集合的差集

（即a＿set与b＿set的差集）

# coding:utf-8

drivers = ['dewei', 'xiaomu', 'xiaoming', 'xiaoman']
testers = ['xiaomu', 'xiaoman', 'xiaogang', 'xiaotao']

driver_set = set(drivers)
test_set = set(testers)

sample_drivers = driver_set.difference(test_set)
print(sample_drivers)

什么是交集

intersection的功能

intersection的用法

a，b两个集合分别拥有的相同的元素集，称为a与b的交集

intersection的功能

intersection的用法

用法：

a_set.intersection(b_set...)

参数：

b＿set．．．：与当前集合对比的1

或多个集合

返回值：

返回原始集合与对比集合的交集

# coding:utf-8

a = ['dewei', 'xiaomu', 'xiaohua', 'xiaoguo']
b = ['xiaohua', 'dewei', 'xiaoman', 'xiaolin']
c = ['xiaoguang', 'xiobai', 'dewei', 'xiaoyuan']

a_set = set(a)
b_set = set(b)
c_set = set(c)

print(a_set, b_set, c_set)

result = a_set.intersection(b_set, c_set)
xiaotou = list(result)
print('{} 是 这个小偷'.format(xiaotou[0]))

什么是并集

 

a，b两个集合中所有的元素（去掉重复）即为a与b的并集 

union的功能

返回多个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次

union的用法

用法：

a_set.union(b_set...)

参数：

bset...·:与当前集合对比的1或多个集合

返回值：

返回原始集合与对比集合的并集

# coding:utf-8

a_school = ['周五半天', '免费周末培训', '周五休息']
b_school = ['放学时间从6点改为5点', '作业少留点', '换舒服的座椅']
c_school = ['作业少留点', '周五半天', '伙食改善']

a_set = set(a_school)
b_set = set(b_school)
c_set = set(c_school)

print(a_set)
print(b_set)
print(c_set)

# help_data = a_set.union(b_set, c_set)
help_data = a_set.union(b_school, c_school)
print(help_data)
print(len(help_data))

{5}--第5章判断两个集合中是否有相同的元素

isdisjoint的功能

判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False

isdisjoint的用法

用法：

a_set.isdisjoint(b_set)

参数：

b＿set：与当前集合用来判断的集合

返回值：

返回一个布尔值True或False

# coding:utf-8

company_not_allow = {'女', '喝酒', '抽烟', '睡懒觉'}

one_player = {'男', '跑步', '朝气', '喝酒'}
two_player = {'女', '生活规律', '跆拳道'}
three_player = {'男', '太极拳'}
four_player = {'男', '空手道', '年轻'}


print(company_not_allow.isdisjoint(one_player))
print(company_not_allow.isdisjoint(two_player))
print(company_not_allow.isdisjoint(three_player))
print(company_not_allow.isdisjoint(four_player))

{2}--Python不同数据类型间的转换

{1}--第1章字符串与数字的转换

字符串与数字间的转换

什么是类型转换，为何做类型转换

将自身数据类型变成新的数据类型，并拥有新的数据类型的所有功能的过程即为类型转换

为方便更好的帮助处理业务，将类型变更为更适合业务场景的类型

str→number：数字组成的字符串

# coding:utf-8

int_data = 12
float_data = 3.14

str_int_data = str(int_data)
str_float_data = str(float_data)
print(str_int_data, str_float_data, type(str_int_data), type(str_float_data))

zero_number = 0
_number = -1

str_zero_number = str(zero_number)
str_number = str(_number)
print(str_zero_number, str_number, type(str_zero_number), type(str_number))

str_float = '3.14'
str_int = 123456

real_float = float(str_float)
real_int = int(str_int)

print(real_float, real_int, type(real_float), type(real_int))

mix_str = '123'
print(float(mix_str))
float_data_str = '3.14'
test_data = float(float_data_str)
print(test_data, type(test_data))

int_data_str = '123'
test_data = float(int_data_str)
print(test_data, type(test_data))

PS D:\Workspace\Python> python number_test.py
12 3.14 <class 'str'> <class 'str'>
0 -1 <class 'str'> <class 'str'>
3.14 123456 <class 'float'> <class 'int'>
123.0
3.14 <class 'float'>
123.0 <class 'float'>
(2}--第2章字符串与列表之间的转换

字符串转列表的函数--split

列表转字符串的函数--join

字符串转列表之split 功能

字符串转列表之split 用法

用法：

string.split(sep=None, maxsplit=-1)

参数：

sep：切割的规则符号，不填写，默认空格，如字符串无空格则不分割生成列表

maxsplit：根据切割符号切割的次数，默认-1无限制

返回值：

返回一个列表

# coding:utf-8

a = 'abc'
print(a.split())

b = 'a,b,cd'
print(b.split(','))

c = 'a|b|c|d'
print(c.split('|', 1))

d = 'a|b|c|d'
print(d.split('|', 2))

# f = ''
# print(f.split(''))

test = ['a', 'b', 'c']
test_str = '|'.join(test)
print(test_str)

test2 = ['c', 'a', 'b']
print('|'.join(test2))

sort_str = 'a b d f i p q c'
sort_list = sort_str.split(' ')
print(sort_list)
sort_list.sort()
print(sort_list)
sort_str = ' '.join(sort_list)
print(sort_str)

sort_str_new = 'abdfipqc'
print(sort_str_new)
res = sorted(sort_str_new)
print(''.join(res))

列表转字符串之join 功能

列表转字符串之join用法

用法：

'sep'join(iterable)

参数：

sep：生成字符串用来分割列表每个元素的符号

iterable：非数字类型的列表或元组或集合

返回值：

返回一个字符串

{3}--第3章字符串与bytes通过编解码进行转换

(4}--第4章列表集合元组的转换

(5}--第5章综合案例:九九乘法表

{3}--Python的流程控制

(1}--第1章初识条件判断

{2}--第2章if-else语句

{3}--第3章Python的循坏

{4}--第4章循环中的continue与break操作

(5}--第5章综合案例:循环实现九九乘法表

{4}--函数的定义与使用

{1}--第1章定义函数

(2}--第2章函数的参数

{3}--第3章函数的参数类型

(4}--第4章局部变量与全局变量

{5}--第5章递归函数

{6]}--第6章匿名函数

(7}--第7章综合案例:实现学生信息库

{04}–第4周Python面向对象与异常处理机制/

{1}--Python面向对象编程

{1}--第1章课程介绍

(2}--第2章初识面向对象

(3}--第3章类中的私有函数与私有变量

{4}--第4章装饰器与类的装饰器

{5}--第5章类的继承与多态

{6}--第6章类的多重继承

(7}--第7章类的高级函数

(8}--第8章综合案例:面向函数转面向对象

(9}--第9章综合案例:升级学生信息库为面向对象形式

{2}--Python异常处理机制

{1}--第1章初识异常

{2}--第2章python内置异常函数

{3}--第3章异常中的finally

{4}--第4章自定义异常

{5}--第5章断言

{6}--第6章python中的调试方法

{05}–第5周Python模块与文件操作/

{1}--Python模块和包

{1}--第1章学习安排

(2}--第2章包与模块的定义与导入

(3}--第3章第三方包

{4}--第4章python的datetime与time

{5}--第5章python内置库os与sys模块

{2}--Python文件操作(io)

{1}--第1章文件的读写

{2}--第2章文件的应用

(3}--常用函数与高阶函数

{1}--第1章加密工具

{2}--第2章日志模块

{3}--第3章虚拟环境

(4}--第4章常用函数的集合

{5}--第5章random模块

{6}--第6章Python的高阶函数

阶段二： Python语法进阶

{06}–第6周多线程编程、正则表达式与综合项目实战/

{1}--进程与线程编程

{1}--第1章课程介绍

(2}--第2章进程与多进程

(3}--第3章线程与多线程

{4}--第4章多进程的创建

{5}--第5章进程池与进程锁

{6}--第6章进程间的通信

(7}--第7章线程的创建

{8}--第8章线程池

{9}--第9章全局锁

{10}--第10章异步

{2}--Python正则表达式

{1}--第1章初识正则

(2}--第2章正则表达式的字符匹配

(3}--第3章正则表达式的量词

{4}--第4章正则的综合练习

(5}--第5章正则表达式的re模块

(3}--综合项目实战:抽奖系统

{1}--第1章项目介绍和环境搭建

(2}--第2章搭建项目基础类

(3}--第3章初始化项目结构

{4}--第4章基础功能开发

(5}--第5章奖品初始化写入与读取

(6}--第6章奖品数量的减少和删除

(7}--第7章对用户添加封禁身份修改

{8}--第8章奖品增删操作

(9}--第9章获取用户与奖品列表

{10}--第10章完善抽奖系统

{07}–第7周Python办公自动化/

{1}--Python办公自动化

{1}--第1章课程介绍

(2}--第2章Python文件自动化管理，让你的电脑不再多乱差

{3}--第3章PythonWord自动化，高效高质量做文档

(4}--第4章PythonExcel自动化，再也不用手动复制粘贴

(5}--第5章PPT自动化，快速排版全靠它

{6}--第6章Python邮件自动化，秒回邮件

(7}--第7章课程总结

阶段三： Python数据库开发与实战

{08}–第8周MySQL数据库/

{1}--MySQL的介绍

{1}--第1章课程介绍

{2}--第2章MySQL的下载与安装(最重要的一章)

(3}--第3章课程总结

(2}--数据库表的相关操作

{1}--第1章课程介绍

(2}--第2章数据库表的创建

(3}--第3章数据库表字段约束

{4}--第4章课程总结

(3}--数据库的基本查询

{1}--第1章课程介绍

(2}--第2章数据操作语言的基本操作(重点章节，建议多练)

(3}--第3章条件查询1(重点章节)

(4}--第4章课程总结

{4}--数据库的高级查询

{1}--第1章课程介绍

(2}--第2章高级查询(重点)

(3}--第3章表的内外连接(重点章节，建议多操作)

(4}--第4章子查询的语法规则(重点章节，建议多听多练)

(5}--第5章课程总结

(5}--MySQL的基本操作

{1}--第1章课程介绍

{2}--第2章数据插入操作

(3}--第3章数据更新操作

(4}--第4章数据删除

{5}--第5章课程总结

{6}--MySQL基本函数的使用

{1}--第1章课程介绍

(2}--第2章MySQL基本函数(重点章节，建议多操作)

{3}--第3章课程总结

{09}–第9周Python与MySQL的交互/

{1}--MySQL的综合应用

{1}--第1章课程介绍

(2}--第2章MySQL数据库的事务机制

(3]--第3章数据的持久化

(4}--第4章综合案例:新闻管理系统数据库设计

(5]--第5章课程总结

{2}--Python+MySQL开发新闻管理系统

{1}--第1章课程介绍

{2}--第2章MySQL与Python的交互

(3}--第3章项目实战:开发新闻管理系统

{4}--第4章课程总结

{3}--Python办公自动化进阶

{1]--第1章课程介绍

(2}--第2章学生信息管理系统

{10}–第10周Redis数据库/

{1}--Redis数据库介绍与安装

{1}--第1章步骤介绍与课程介

(2}--第2章Redis数据库的安装和配置

{3}--第3章课程总结

(2}--Redis常用数据结构

{1}--第1章课程介绍

(2}--第2章Redis常用数据结构

{3}--第3章Redis中常用命令

{4}--第4章课程总结

{3}--Redis事务特性

{1}--第1章课程介绍

(2}--第2章Redis事务特性

(3}--第3章课程总结

{4}--Redis与Python的交互

{1}--第1章课程介绍

{2}--第2章Redis与Python的交互

(3}--第3章课程总结

{5}--Python+Redis开发新闻管理系统

{1}--第1章课程介绍

(2}--第2章综合案例新闻管理系统应用开发

(3}--第3章课程总结

{11}–第11周MongoDB数据库/

[1}--MongoDB数据库介绍与安装

[2}--MongoDB的基本操作

[3}--数据的导入导出

[4}--MongoDB与Python的交互

[5}--项目实战:MongoDB完善新闻管理系统

阶段四： Python爬虫工程师

{12}–第12周开发必备前端基础之HTML与CSS/

{1}--HTML入门

{1}--第1章导学

{2}--第2章概述

(3}--第3章常用标签

{4}--第4章表格

{5}--第5章表单

{6}--第6章综合作业

{2}--CSS入门

{1}--第1章概述

{2}--第2章CSS基本使用

(3}--第3章CSS常用样式

(4}--第4章伪类和伪元素

{5}--第5章其他选择器

{3}--CSS浮动

{1}--第1章概述

(2}--第2章DIV

{3}--第3章盒子模型

{4}--第4章浮动

{5}--第5章清除浮动

{4)--CSS定位

{1}--第1章概述及相对定位

{2}--第2章绝对定位

(3}--第3章相对定位和绝对定位

{4}--第4章定位和浮动

(5}--第5章z-index的使用

{6}--第6章固定定位

(7}--第7章定位案例及课程总结

{13}–第13周开发必备前端基础之JavaScript与jQuery/

{1}--JavaScript入门

{1}--第1章课程介绍

{2}--第2章概述及第一个js程序

{3}--第3章自定义函数与数据类型

(4}--第4章变量与运算符

{5}--第5章程序控制语句

{6}--第6章函数

(7}--第7章数组

{8}--第8章表单元素设置

(9}--第9章DOM与事件总结

{2}--案例:仿计算器

{1}--第1章准备工作

(2}--第2章页面实现

{3}--第3章功能实现

(3}--前端油画商城案例

{1}--第1章概述

{2}--第2章logo和menu区域设计

(3}--第3章商品展示区制作

{4}--第4章页脚区

{4}--入门jQueny编程

{1}--第1章课程介绍

{2}--第2章jQuery对象和操作

{3}--第3章jQuery事件

{4}--第4章课程总结

{14}–第14周初探网络爬虫/

{1}--爬虫基础入门

{1}--第1章课程介绍

(2}--第2章爬虫工程师基本功--网络基础

{3}--第3章requests模块的深度解析

{4}--第4章课程总结

{2}--网络爬虫的环境集成

{1}--第1章课程介绍

(2}--第2章CentOsLinux系统的安装

(4}--第4章CentOs中常用工具的集成

{5}--第5章课程总结

{15}–第15周网络爬虫进阶与实战/

{1}--网络爬虫常用技术

{1}--第1章课程介绍

(2}--第2章正则表达式在爬虫中的应用

{3}--第3章xpath在爬虫中的应用

{4}--第4章BeautifulSoup4在爬虫中的使用

{5}--第5章lxml解析数据

(6}--第6章使用MongoDB存储爬取的数据

(7}--第7章课程总结

{2}--网络爬虫进阶--项目实战

{1}--第1章电影信息抓取项目实战
 

(2}--第2章课程总结

{16}–第16周高级爬虫框架/

(1}--可视化爬虫框架Selenium

{1}--第1章课程介绍

(2}--第2章selenium模块的基本使用

(3}--第3章元素定位和网页交互

(4}--第4章在Linux系统中应用selenium

{5}--第5章案例实战

(6}--第6章课程总结

{2)--异步网络爬虫框架Scrapy

{1}--第1章课程介绍

{2}--第2章Scrapy框架介绍

{3}--第3章详解Scrapy框架

{4}--第4章课程总结

{17}–第17~18周高级爬虫项目实战与爬虫面试指导/

{1}--爬虫与反爬虫

{2}--Scrapy爬虫项目实战

(3}--Scrapy-Redis分布式爬虫实战

(4}--Git代码管理工具

{5}--爬虫面试指导

{6}--综合就业指导

阶段五： Python数据分析工程师

{18}–第19周数据分析入门/

{1}-数据分析认知

{1}--第1章课程介绍

(2}--第2章数据分析认知

{3}--第3章从Excel开始认知数据分析

{4}--第4章课程总结

{2}--数据分析核心库之NumPy与Pandas

{1}--第1章科学计算库NumPy

(2}--第2章数据分析库Pandas

(3}--第3章数据分析实战:数据预处理、统计与分析

{4}--第4章课程总结

{19}–第20周数据分析进阶：数据可视化/

{1}--数据可视化之Matplotlib

{1}--第1章课程介绍

(2}--第2章认识Matplotlib可视化库

(3}--第3章创建可视化图表

{4}--第4章课程总结

{2}--数据可视化之Seaborn

{1}--第1章课程介绍

{2}--第2章认识Seaborn可视化库

{3}--第3章Seaborn绘图

{4}--第4章课程总结

{20}–第21周数据分析进阶：统计分析与机器学习/

{1}--数据分析进阶：统计分析与机器学习

{1]--第1章课程介绍

{2}--第2章Scipy:统计分布、线性回归

(3]--第3章Scikit-Learn挖掘数据特性

{4}--第4章课程总结

{21}–第22周数据分析项目综合实战与就业指导/

{1}--数据分析综合实战

{1}--第1章课程介绍

{2}--第2章项目实战:一线城市房价分析

{2]--数据分析就业指导

{1}--第1章课程介绍

(2}--第2章面试准备与技巧

阶段六： Python全栈之从网页搭建入门到Flask全栈项目

{22}–第23周企业级开发语言ES6与前端开发框架Bootstrap/

{1}--ES6标准入门和Flex布局

{2}--入门前端框架Bootstrap

{3}--前端实战:开发在线问答系统各个功能模块

{23}–第24周夯实框架基础：Python全栈开发必学后端主流框架Flask/

{1}--入门Flask微框架

{1}--第1章课程介绍

{2}--第2章入门Flask框架

(3}--第3章MTV模型

{4}--第4章Flask扩展

{5}--第5章HTTP基础和识

{6}--第6章Flask请求与响应报文

(7]--第7章Flask视图

{8}--第8章课程总结

(2}--Flask模板语法与继承

{1}--第1章课程介绍

{2}--第2章入门Flask模板

{3}--第3章Flask模板语法

{4}--第4章Flask模板中的宏

{5}--第5章Flask模板的继承

{6}--第6章消息闪现

{7}--第7章课程总结

{3}--Flask中的ORM使用

{1}--第1章课程介绍

{2}--第2章环境安装

{3}--第3章ORM的CURD操作

{4}--第4章课程总结

{4}--Flask表单的实现

{1}--第1章课程介绍

{2}--第2章表单介绍

(3}--第3章表单验证与图片上传

(4}--第4章课程总结与技巧分享

{24}–第25周项目实战：Flask实战开发在线问答系统/

{1}--Flask开发实现在线问答系统的首页功能

{1}--第1章课程介绍

(2}--第2章前端页面与Flask框架整合

{3}--第3章在线问答系统ORM分析与实现

{4}--第4章Flask蓝图

{5}--第5章开发在线问答系统的首页模块

(6}--第6章课程总结

(2}--Flask开发实现用户的注册和登录功能

{1}--第1章课程介绍

{2}--第2章开发注册页面

(3}--第3章Flask实现登录验证

{4}--第4章课程总结

{3}--Flask开发在线问答系统的问题发布功能

{1}--第1章课程介绍

{2]--第2章发布模块的开发

(3}--第3章入门Ajax

{4}--第4章入门Flask-RESTfull

{5}--第5章课程总结

{4}--Flask开发在线问答系统的点赞评论模块

{1}--第1章课程介绍

{2}--第2章开发评论与点赞模块

(3}--第3章课程及阶段总结

阶段七： Python全栈之Django+Vue前后端分离商业级全栈项目

{25}–第26周入门PythonWeb全栈开发必备主流框架Django/

{1}--初识Django框架

{1}--第1章Django全栈项目介绍

{2}--第2章初识Django框架

(3}--第3章从请求到响应

{4}--第4章课程总结

(2}--Django模板

{1}--第1章课程介绍

{2}--第2章Django模板介绍及使用

{3}--第3章课程总结

{26}–第27周DjangoORM模型和表单/

{1}--Django中的ORM模型

{1}--第1章ORM模型介绍

(2}--第2章使用ORM实现CRUD操作

(3}--第3章深入查询及事务处理

{2}--Django表单应用

{1}--第1章表单的基本使用

(2}--第2章自定义表单

{3}--第3章文件上传

{27}–第28周前端框架基础：前端开发必学Vue框架/

{1}--入门全栈开发前端必学框架VUE

{1}--第1章课程介绍

{2}--第2章入门Vue框架

(3}--第3章Vue基础语法

{4}--第4章Vue过滤器与组件通信

{28}–第29周项目实战：Django+Vue全栈开发旅游网项目首页/

{1}--Django+Vue全栈开发慕旅游网首页

{1}--第1章前端项目搭建

{2}--第2章网络请求库axios

(3}--第3章跨域问题

(4}--第4章前端组件开发

{5}--第5章后台接口开发

{6}--第6章接口联调

(7}--第7章课程总结

{29}–第30周项目实战：Django+Vue全栈开发旅游网项目景点详情/

{1}--Django+Vue全栈开发景点详情模块

{1}--第1章课程介绍

({2}--第2章VueRouter实现多个页面

(3}--第3章景点详情页面开发

{4}--第4章API接口设计及开发

(5}--第5章接口联调

{6}--第6章课程总结

{30}–第31周项目实战：Django+Vue全栈开发旅游网项目登录注册/

{1}--初识Redis高速缓存及应用

{1}--第1章课程介绍

{2}--第2章Redis高速缓存的应用

(2}--开发慕旅游网用户登录注册前端页面

{1}--第1章Django用户模型

(2}--第2章Vuex状态管理

{3}--第3章前端页面开发

(3]--慕旅游网用户登录注册接口开发与联调

{1}--第1章接口开发

{2}--第2章接口联调

(3}--第3章课程总结

{31}–第32周项目实战：Django+Vue全栈开发旅游网项目订单支付/

{1}--实战开发慕旅游网下单支付前端页面

{1}--第1章课程介绍

(2}--第2章前端页面开发

{2]--慕旅游网下单支付接口开发与联调

{1}--第1章接口开发

{2}--第2章接口联调

(3}--第3章课程总结

{32}–第33周项目实战：全栈开发旅游项目后台管理系统与项目部署/

{1}--实战开发慕旅游网后台管理系统

{1}--第1章后台管理

{2}--第2章使用admin管理景点

{3}--第3章订单管理

{4}--第4章项目总结

{2}--慕旅游网项目部署

{1}--第1章项目部署

阶段八： Python技能拓展

{33}–第34~35周Python技能拓展之软件自动化测试/

{1}--软件自动化测试基础

{1}--第1章课程介绍

{2}--第2章项目的生命周期

{3}--第3章什么是软件测试

{4}--第4章什么是自动化测试

{5}--第5章课程总结

{2}--慕旅游网项目实战接口自动化测试

{1}--第1章课程介绍

{2}--第2章什么是接口测试

{3}--第3章接口测试基础

{4}--第4章接口测试工具的使用

{5}--第5章慕旅游网接口测试实战

{6}--第6章课程总结

{3}--慕旅游网项目实战Web自动化测试

{1}--第1章Web自动化测试基础

{2}--第2章Selenium元素定位操作

{3}--第3章慕旅游网Web自动化测试实战

{4}--第4章综合作业

{5}--第5章课程总结

{4}--APP自动化测试项目实战

{1}--第1章APP自动化测试基础

{2}--第2章APP自动化测试实战

{3}--第3章课程总结

{34}–第36周Python技能拓展之人工智能/

{1}--第1章课前准备

{2}--第2章AI核心开发工具与常用工具包

{3}--第3章AI带着答案学习：监督学习

{4}--第4章AI自己找规律：无监督学习

{5}--第5章AI拓展：技术领域介绍

{6}--第6章进阶学习路线