标签：ack lam UNC 1年 知乎 土豆 app spl 回收机制
python的创始人为吉多·范罗苏姆（Guido van Rossum）。
1989年的圣诞节期间，吉多·范罗苏姆（中文名字：龟叔）为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。
（龟叔：2005年加入谷歌至2012年，2013年加入Dropbox直到现在，依然掌握着Python发展的核心方向，被称为仁慈的独裁者）。
2019年6月的TIOBE排行榜，Python占据第三的位置， Python崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。
Python整体呈上升趋势，反映出Python应用越来越广泛并且也逐渐得到业内的认可！
编程语言主要从以下几个角度为进行分类，编译型和解释型、静态语言和动态语言、
强类型定义语言和弱类型定义语言，我们主要通过编译型和解释性来划分Python是什么编程语言
编译器 是把源程序的每一条语句都编译成机器语言,并保存成二进制文件,这样运行时
计算机可以直接以机器语言来运行此程序,速度很快;
而解释器则是只在执行程序时,才一条一条的解释成机器语言给计算机来执行,
所以运行速度是不如编译后的程序运行的快的.
为什么会有编译型好解释型语言是因为计算机不能直接认识并执行我们写的语句,它只能认识机器语言(是二进制 的形式)
编译型 优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。
解释型 优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。
缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。
通常我们所说的动态语言、静态语言是指动态类型语言和静态类型语言。
(1）动态类型语言：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，
在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，
在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如
VBScript也多少属于动态类型语言。
(2）静态类型语言：静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，
也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，
其他的静态类型语言还有C#、JAVA等。
(1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，
如果不经过强制转换，那么它就永远是这个数据类型了。
举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。
强类型定义语言是类型安全的语言。
(2）弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反,
一个变量可以赋不同数据类型的值。
强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避
免许多错误。另外,“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！
例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语
言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。
通过上面这些介绍，我们可以得出. Python是一门动态解释性的强类型定义语言。
Python的官方版本，使用C语言实现，使用最为广泛，CPython实现会将源文件（py文件）
转换成字节码文件（pyc文件），然后运行在Python虚拟机上。
Python的Java实现，Jython会将Python代码动态编译成Java字节码，然后在JVM上运行。
IronPython
Python的C#实现，IronPython将Python代码编译成C#字节码，然后在CLR上运行。（与Jython类似）
PyPy（特殊）
Python实现的Python，将Python的字节码字节码再编译成机器码。
看了这么多内容,感觉好厉害已近迫不及待的想要动手去试试了,我不得不说,还是需要在稍等一下.我们需要安装一下Python解释器
向下查找,找到Python 3.6.3
根据当前系统的选择对用的,红色的是windows32位,绿色的是windows64位
下载完成后找到下载的目录,然后用鼠标左键双击
打开电脑的终端(黑窗口),输入 python回车进去python解释器,返回的结果入下图:
在终端中 >>> 输入exit() 如下图:
使用Windows系统使用Notepad++创建一个文本,文本中的内容如下:
print("hello world")写完后一定要记得保存,保存完后我们打开我们的终端,Windows系统的找到图下的两个键:
使用Mac系统的电脑首先打开 启动台 — 其他 — 终端 — 输入 vim 文件名字 然后按键盘i 进行输入然后退出的时候按一下esc键 发现文件的左下角有个: 然后在这个位置输入wq! 回车就行了,具体的请看图下实例
我们现在都打开了终端后再终端中输入以下命令:
python 文件名.py注意点:python和文件名是有空格的,再次确定一下大家的现在是不是都是这个样子的:
print() 括号里面的内容就是要输出的内容,如果是文字和字母需要用英文的引号引起来,数字直接写就可以啦
python2写法:
print 'hello world'
python3写法:
print('hello world')
我们学习的python3版本,python2版本是什么样也要知道我们现在成功的将英文的打印出来了,现在我们使用这种方式打印一下中文的内容吧!
print("你好 世界")然后将文件保存了,保存后我们在来终端上运行一次.是不是都出现报错了,出现报错这个是正常的,我们只需要在加上一句话就可以了.
#conding:utf-8这局话必须要加在文件的第一行,这个是告诉解释器当文件中出现中文的时候使用utf-8的编码进行查看
什么是变量?
变量就是把程序运行的中间结果临时存在内存中,以便后续代码使用
这个知识点用在哪呢? 变量在程序中经常会被使用
变量如何使用?
name = "meet"这样就是在定义一个变量,我们具体说一下定义变量
name 是一个变量名
= 是一个赋值操作 赋值就是将值交给name
'Meet' 是一个值变量的作用:昵称,就是代指内存中某个地址中的内容
我们定义变量的时候,可以任意起名字吗? 应该是有规则的吧,我们来看看变量定义的规则
变量名由字母,数字,下划线组成
变量名禁止使用数字开头
禁止使用Python中的关键字以及内置函数的名字
关键字如下:
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']不建议使用中文和拼音
变量名要具有意义
变量名区分大小写
推荐写法:
这是两种写法,你们觉得那种的比较清晰.是不是第二种看着比较清晰,第一种猛的一看还以为是AngelaBaby呢
我们现在定义一个变量知道了,看看定义多个变量
name1 = 'Meet'
name2 = 'Guo'
此时的name1的值是Meet,name2的值是Guo,我们来看看下边的这个变量
现在我们在内存中开辟了两个空间,分别给不同的内存地址贴上不同的标签,我们来看看下边的代码
name1 = 'Meet'
name2 = name1
现在的这个name1是meet,name2是name1 也就是name2现在用的是name1的值,name2的值就是meet
我们在来看一下变量的小高级使用:
age1 = 18
age2 = age1
age1 = 12
age3 = age2
print(age1,age2,age3)
我们先来分析一下这个结果是怎样的,在运行看结果是否和你想的一样
如果结果和你想的不一致,你需要注意了.咱们代码的运行是从上至下的执行,并且在内存中只能用一个名字相同的标签.
age = 12
age = 12 + 1
age1 = age + 1
print("我今年:",age1)
name1 = 'alex'
name2 = name1
name1 = 'wusir'
name3 = name2
打印name1,name2name3分别对应的值是什么
通过上边的小高级和练习我们可以得出一个宗旨,代码是从上向下执行,并且便签只能有一份,相当于一个变量名只能代指一个值
常量就是将变量名大写,尽量保持不更改的一种量 这个常量有是干什么的呢 其实我生活中就有一些定死了的量 比如生日,身份证等 咱们代码中，也应该有一些这样的东西，咱们从设计之初就是不让任何人改变的，所以这个东西就是常量。
在你写代码时，有些代码写的比较经典，或者过于复杂，你一眼看不出来，怎么办，比如在文言文中，有些出处或者偏难怪的文字，你是不是不理解？ 那么怎么办呢？是不是就得有简单说明。
注释就是做这个的,我们来看一下怎么用
# 这个就是给这一行进行注释,注释后的代码不会执行
'''
这种的是多行注释, 什么是多行注释啊,其实很简单就是咱们注释的内容可以
进行换行
'''
看个示例:
# print('hello') 这样就是对这个代码进行注释,并且这个代码不会执行
'''
print(1)
print(2)
这种就是多行注释,这样的注释也不会执行
'''
什么是数据类型？
我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东西，其实就是对常用的各种数据进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，今天我们暂只讲3种， 数字、字符串、布尔类型
int是整型;也就是我们从小就接触的数学中的整数,整型在计算机中运于计算和比较
在32位机器上int的范围是: -231～231-1，即-2147483648～2147483647
在64位机器上int的范围是: -263～263-1，即-9223372036854775808～9223372036854775807
目前这些数字已经够你用了吧. 注意这些是整数.
num1 = 2
num2 = 3
print(num1 + num2)
# 结果: 5
# 整型就和我们学的数学一样可以进行加减乘除
str是字符串;也就是我们从小就接触的中文,如果我们在程序中直接把中文写入,程序是不能分辨这是个什么鬼东西.所以我们要遵循一种规则让计算机能够识别,这个规则就是只要是用引号引起来就是字符串
在Python中,凡是用引号引起来的,全是字符 .
字符 可以用单引号，双引号，或者三引号引起来，没有什么区别，只是一些特殊的格式需要不用的引号 比如：
msg = "My name is Alex , I'm 22 years old!" 这个就需要单双引号配合。
msg =
""" 今天我想写首小诗，
来歌颂我的同桌，
你看他那乌黑的短发，
好像一只炸毛鸡。
"""
想写多个内容还需要使用换行的时候,就需要三引号。
数字类型可以做运算,字符串可以吗??
字符串加法
#字符串的拼接
s1 = 'a'
s2 = 'bc'
print(s1 + s2)
字符串乘法
str*int name = '坚强'
print(name*8)
bool是布尔值,布尔值中一共分为俩个状态
True 就是真
False 就是假
例如我们想让计算机帮我们计算一下两个数的比较大小
print(3>7)
结果: False
print(7>3)
结果: True
我们现在简单的认识了这三个基础数据类型,我们在学习一下用户输入
咱们在登录一些网页和QQ的时候是不是常常会让咱们输入账户或者密码的情况,
这样的情况在程序中会大量的存在，接下来咱们自己实现一个登录时候要输入的功能
s = input('请输入你喜欢的东西')
input就是固定格式,他是输入的意思 括号里边的内容是提示是给用户看的提示语句,用户输入的内容让input接收了然后赋值给了字符串s
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#将用户输入的内容赋值给name变量
python2的写法
name = raw_input("请输入用户名:")
print name
python3的写法
name = input("请输入用户名:")
print(name)
需要注意的是input程序交互获取到的内容都是字符串,我们看下面的简单示例:
num = input('请输入数字:')
print(num + 5)
结果:
请输入数字:6
Traceback (most recent call last):
File "D:/python_object/test.py", line 350, in <module>
print(num + 5)
TypeError: must be str, not int
报错了,提示我们类型错误,数字和字符串是不能相加的.可是我们输入的明明是数字啊.其实我们看着输入的是 数字,但是input获取到的都是字符串
这个知识点用在哪里?
在工作中如果需要用户输入一些个人信息比如账号，密码，性别，爱好等，即是你需要将你输入的信息传递给程序当中，那么就需要用到用户交互input。
注意
在Python2 中使用raw_input 获取的都是字符串
在Python3 中使用input 获取的都是字符串
你在生活中是不是经常遇到各种选择，比如玩色子，猜大小，比如选择走那条路回家？Python程序中也会遇到这种情况，这就用到了if语句。
这个功能就是Python中的流程控制语句if。 那么如何使用这个功能呢？（下面就是）
if 条件: #引号是将条件与结果分开。
结果# 四个空格，或者一个tab键，这个是告诉程序满足这个条件的结果。切记空格和tab键不能混合使用
age = input("输入年龄:")
if int(age) >= 18:
print("成年了,能干成年人的事了")
age = input('请输入您的年龄:')
if int(age) > 18:
print('你可以去网吧尽情的嗨皮了')
else:
print('你现在还不行啊!')
以上这种写法是让用户输入内容,然后进行比较,如果一个条件成立那就执行print,为了明确的区分改执行哪些部分,当条件成立后执行缩进的代码
然后程序就退出了.下边的else就不会在执行了
num = input('请输入要比较的数字:')
if int(num) >= 22:
print('可以扯证了')
elif int(num) >= 18:
print('成年了,可以干一些成年的事了')
elif int(num) < 18:
print('还是小屁孩')
以上写法就是我们做的单选题一样,三个分支判断中只要有个成立,其余都不在执行
num = input("请输入要比较的数字:")
if num > 60:
print("大了")
elif num < 60:
print("小了")
else:
print("猜对了")
name = input('请输入名字:')
if name == 'meet':
age = input('请输入年龄:')
if int(age) == 18:
print('输入全部正确')
else:
print('年龄输入错误!')
else:
print('名字输入错误!')
这样写法很常用,这样我们就可以明确的知道用户输入的名字和年龄那个是错误的,并且还做一个判断如果名字正确后在进行判断密码
首先要下载Pycharm这个软件，官网的下载地址是: http://www.jetbrains.com/pycharm/download/#section=windows
选择左边的点击进行下载,左边的是专业版右边是社区版
出现这个页面就是正在下载,稍微喝杯茶等等
选择Next 点击
我是64位机器,我选择了64,如果是32的就选择32 [不管64还是32剩下的都选择]
出现这个界面的直接点击Finish关闭就可以了. 我们现在切换到桌面
找到这个图标然后双击
激活详情http://idea.lanyus.com/页面 
点击选择的内容生成激活码,然后将激活码复制到code选项中
这个直接关闭就可以了
如果你的激活码没问题的话，会在个性化，主题设置完毕之后，经过短暂的加载（加载速度取决于电脑性能）进入如图页面，到这一步，PyCharm安装完成了
File -- Settings -- Project -- Project Interpreter,这里会显示当前系统默认的解释器，如果要添加别的解释器，点击工具图标，Add local -- Existing environment,点击三点图标，在打开的本地文件目录中选择解释器文件的.exe文件。就行了，如果你没有选择， PyCharm会自动选择当前环境默认的解释器
鼠标放到大纲然后右键鼠标,出现一个New然后鼠标向右滑动选择python file点击左键
直接写文件的名字就可以了,写完后回车就搞定了.
while 循环 在生活中，我们遇到过循环的事情吧？比如循环听歌。在程序中，也是存才的，这就是流程控制语句 while
while 条件:
# 循环体
# 如果条件为真，那么循环则执行
# 如果条件为假，那么循环不执行
条件如果为真就会一直执行下去 也就人们常说的死循环,我们想要停止就点那个红色的方块,如果点击的x的话,程序并没有停止,还在继续运行着
我们可以使用while循环进行内容循环,我们怎么能够让程序停止运行?
刚刚说到,死循环是因为条件一直都为真的时候,如果想让while循环停止最简单的方式就是将条件修改成假的,看下面示例
flage = True
str_num = input("请输入要比较的数字:")
print("进入循环")
while flage:
if "3" > str_num:
print("在执行循环")
else:
print("要终止循环")
flage = False
print("退出循环")
我们现在知道可以通过变量的形式改变while循环,我们还可以通过计数的方式来控制循环执行循环的次数,先来看一下
count = 0
while True:
count = count + 1
print(count)
这样下去我就会执行下去,但是我想到100就停了
count = 0
while count < 100:
count = count + 1
print(count)
while 关键后边的是条件,这样就可以通过条件成功的控制住循环的次数,我们现在知道通过修改while后边的内容来终止循环,这是咱们自己想的办法,python这个编程语言中是不是应该也得有个终止循环的关键字什么的吧,我们来找一下试试
我们除了可以使用条件能够让循环停止,其实Python还给我们提供了一个break关键字来停止循环
num = 1
while num <6:
print(num)
num+=1
break
print("end")
当程序执行到break的时候就结束了.break就是结束当前这个while循环的 break以下的代码都不执行
continue 用于退出当前循环，继续下一次循环
num = 1
while num <6:
print(num)
num+=1
continue
print("end")
注意:break是终止循环,continue是跳出本次循环,继续下次循环
# 循环一
while True:
if 3 > 2:
print('你好')
break
else:
print('不好')
# 循环二
while True:
if 3 > 2:
print('你好')
print('不好')
# 大家看到的这个是不是感觉效果是一样的啊,其实不然
# 当上边的代码执行到break的时候else缩进后的内容不会执行
这个执行的效果是因为
循环一执行了循环也执行了if条件打印了你好然后碰到break循环结束了
循环二执行了循环也执行了if条件打印了你好,但是没有break 就继续重复执行了
循环一将3>2改成3<2这个条件就不成立,然后执行了else里打印了不好
首先让用户输入序号选择格式如下:
0.退出
1.开始登录
如果用户选择序号0 就提示用户退出成功
如果用户选择序号1就让用户输入用户名密码然后进行判断,正确就终止循环,错误重新输入
现在有个需要我们录入我们身边好友的信息,格式如下:
------------ info of Alex Li ----------
Name : Alex Li
Age : 22
job : Teacher
Hobbie: girl
------------- end ----------------
我们现在能想到的办法就是用一下方法:
name = input('请输入姓名:')
age = input('请输入年龄:')
job = input('请输入职业:')
hobby = input('请输入爱好:')
a = '------------ info of Alex Li ----------'
b = 'Name:'
c = 'Age:'
d = 'Job:'
e = 'Hobby:'
f = '------------- end ----------------'
print(a+
'\n'+
b+
name+
'\n'+
c+
age+
'\n'+
d+
job+
'\n'+
e+
hobby+
'\n'+
f)
# 运行结果
------------ info of Alex Li ----------
Name:meet
Age:18
Job:it
Hobby:3
------------- end ----------------
这样写完全没有问题,但是会不会比较繁琐呢,有些大佬肯定会想这不都实现了吗,还逼叨逼什么啊,那是没有体验过格式化输出有多霸道,我们现在来体验下霸道的姿势
name = input('请输入姓名:')
age = input('请输入年龄:')
job = input('请输入职业:')
hobby = input('请输入爱好:')
msg = '''
------------ info of Alex Li ----------
Name : %s
Age : %s
job : %s
Hobbie: %s
------------- end ----------------
'''
print(msg%(name,age,job,hobby))
% 是一个占位, 回想下我们小时候给朋友占位子的场景,是的这个就是占位.那s又是什么呢? s代码的字符串类型;
name = input('>>>')
s1 = '1234%d'%int(name)
s2 = '1234%i'%int(name)
print(s1)
print(s2)
结果:
>>>89
123489
123489
# %d和%i这种格式化只能用数字来填补占位
num = input('>>>')
s= '目前学习进度:%s%%'%num
print(s)
结果:
>>>80
目前学习进度:80%
# 如果我们字符串中想要显示单独的%就需要用来个%%来转义,不然程序会认为那是一个占位
计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算.
今天我们暂只学习 算数运算、比较运算、逻辑运算、赋值运算、成员运算
以下假设变量：a=10，b=20
以下假设变量：a=10，b=20
以下假设变量：a=10，b=20
针对逻辑运算的进一步研究：
在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。
例题：
判断下列逻辑语句的True，False。
x or y , x为真，值就是x，x为假，值是y；
x and y, x为真，值是y,x为假，值是x。
3>4 or 4<3 and 1==1
1 < 2 and 3 < 4 or 1>2
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
例题：求出下列逻辑语句的值。
8 or 4
0 and 3
0 or 4 and 3 or 7 or 9 and 6
in not in :
判断子元素是否在原字符串（字典，列表，集合）中：
例如：
#print('喜欢' in 'dkfljadklf喜欢hfjdkas')
#print('a' in 'bcvd')
#print('y' not in 'ofkjdslaf')
咱们的电脑，存储和发送文件，发送的是什么？电脑里面是不是有成千上万个二极管，亮的代表是1，不亮的代表是0，这样实际上电脑的存储和发送是不是都是010101啊
我们发送的内容都是010101010这样写的内容比较多就不知道是什么了,所以我们想要明确的区分出来发送的内容就需要
在某个地方进行分段.计算机中设定的就是8位一断句
计算机:
储存文件,或者是传输文件,实际上是010101010
计算机创建初期,美国,是7位一段，但是发明者说为了拓展，留出一位，这样就是8位一段句。8位有多少种可能 ？256
密码本:
ascii
00000001
01000001 01000010 01000011 ABC
随着计算机的发展. 以及普及率的提高. 流?到欧洲和亚洲. 这时ASCII码就不合适了. 比如: 中?汉字有几万个. 而ASCII 多也就256个位置. 所以ASCII不行了. 怎么办呢? 这时, 不同的国家就提出了不同的编码用来适用于各自的语言环境. 比如, 中国的GBK, GB2312, BIG5, ISO-8859-1等等. 这时各个国家都可以使用计算机了.
GBK, 国标码占用2个字节. 对应ASCII码 GBK直接兼容. 因为计算机底层是用英文写的. 你不支持英文肯定不行. 而英文已经使用了ASCII码. 所以GBK要兼容ASCII. 这里GBK国标码. 前?的ASCII码部分. 由于使?两个字节. 所以对于ASCII码?言. 前9位都是0
字母A:0100 0001 # ASCII
字母A:0000 0000 0100 0001 # 国标码
随着全球化的普及，发展到欧洲，亚洲等国家，发现这些根本不够用，所以创建了万国码。 因为全球语言很多,ascii不足以存储这么多对应关系,创建了一个超级密码本:万国码unicode
8 位 == 1个字节.
hello h一个字符,e一个字符,he就不是一个字符.
中国:中是一个字符,国是一个字符.
创建之初,16位,2个字节,表示一个字符. 英文: a b c 六个字节 一个英文2个字节 中文 中国 四个字节 一个中文用2个字节
但是这种也不行，这种最多有65535种可能，可是中国文字有9万多，所以改成 32位,4个字节,表示一个字符.
a 01000001 01000010 01000011 00000001 b 01000001 01000010 01100011 00000001 中 01001001 01000010 01100011 00000001 浪费资源.
对Unicode进行升级: utf-8 utf-8 用最少用8位数,去表示一个字符. 英文: 8位,1个字节表示. 欧洲文字: 16位,两个字节表示一个字符. 中文,亚洲文字: 24位,三个字节表示.
utf-16 用最少用16位数。
gbk: 国标,只能中国人自己用, 一个中文用16位,两个字节表示。
8bit = 1byte
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024TB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
常?到TB就够了
整型在Python中的关键字用int来表示; 整型在计算机中是用于计算和比较的
在python3中所有的整数都是int类型. 但在 python2中如果 数据量比较大. 会使用long类型.
在python3中不存在long类型 整数可以进行的操作:
a = 10
b = 20
print(a + b)
结果:
30
a = 10
b = 20
print(b - a)
结果
10
a = 10
b = 20
print(a * b)
结果:
200
a = 10
b = 20
print(b / a)
结果:
2.0
# 注意点:当我们使用Python3的时候我们除法获取到时浮点数,也就是小数,但是使用Python2的时候使用除法获取的就是整数
a = 10
b = 20
print(b // a)
结果:
2
a = 5
b = 2
print(a % b)
结果:
1
a = 5
b = 2
print(a ** b)
结果:
25
注意点: 在Python2中存在long(长整型) 但是在 Python3中long(长整型)不存在
我们常说的数字都是10进制的,数字表示的形式有很多种,我们今天就简单的说一下 十进制数 和 二进制数
他们之间是如何转换,我们先来看看十进制转换二进制,使用一种整除法,例如十进制的数是15我们想要知道15的二进制是多少就除以2获取他的余数然后从下向上将这些余数拼到一起,就是用以下的方法
我们现在知道怎么将十进制的数转换成二进制,那就再来看看怎样将二进制的数转换成十进制.
我们使用110001来举例,现在想要获取到这个二进制的数然后转换成十进制 要进行如下操作
接下来的计算我们就从右向左计算,用最右侧的数乘以2的0次方,依次向左推
1*2**0 + 0*2**1 + 0*2**2 + 0*2**3 + 1*2**4 + 1*2**5 换算下来就是
1 + 0 + 0 + 0 + 16 + 32 = 49
我们使用这种办法就能将二进制的数转换成十进制的数
布尔值(bool) 判断真假
python语法 人类语言 计算语言
True 真 1
False 假 0
n = int('22')
print(n)
结果:22
#注意点: 字符串中的内容必须是阿拉伯数字才能强行转换
n = str(22)
print(n)
结果:
2 看到的效果是像是数字,实际上就是字符串,我们可以使用type查看类型
n = bool(4) # bool(-1) 结果也是True
print(n)
结果:
True
注意点: 使用bool转换的时候只要是非0的都为True
n = int(True) # int(False) 结果是0
print(n)
结果:
1
n = bool(' ')
print(n)
结果:
True
注意点: 只要字符串中的内容不为空, 所得到的结果就是True
n = str(True)
print(n)
结果:
True 这是一个字符串的True
在第一天的时候咱们简单的认识了下字符串,今天我们好好的来认识一下这个让你又喜又优的字符串
我们来回忆下字符串是不是可以进行加减乘除
a = '世界'
b = '你好'
print(a + b)
结果:
世界你好
通过刚刚我们的测试发现字符串也是可以进行加法操作的,字符串相加其实有个专业的名词 --- 字符串拼接;相加的规则就是必须都是字符串才能相加
字符串中是不能进行减法和除法操作的,通过这句话就能得知字符串是可以进行乘法操作的,我们立马来看一下:
a = '坚强'
print(a * 8)
结果:
坚强坚强坚强坚强坚强坚强坚强坚强
字符串的乘法 就是 将多个字符串拼接到一起, 乘法的规则:只能是字符串和数字相乘
我们回顾完第一天的字符的内容,那就来看看咱们今天要讲的内容是什么??
大家在上学的时候就会发现在一个班有的同学的名字是一样的,最后大家为了好区分就有了外号,我们每个人都有个学号,其实学校就是为了防止重名找错人,
学号就是一种能够保证唯一且准确的手段,这种手段在计算机中存在,这种手段叫做索引,也有人称之为下标.
图上就是对"meet"字符串进行索引排号,其实图上有一点大家不难看出m对应的是数字0,如果让我们人来给排号.下意识的会从1开始.
因为我们从小的时候就是从1开始数数的,但是在计算机中数数确实要从0开始,其实这个点也是对程序的入门.
以后在碰到这种类似的问题我们就知道是从0开始计数,废话不多说我们来看看,我说的到底行不行.
name = 'meet'
# 索引 0123
print(name[0])
结果:
m
细心的老铁们会发现这[ ]是干啥的,这个是一个查找,我不知道字符串中第一个是什么,但是我知道第一个的索引,我就可以通过这个方式来查看
比方:我不知道这个学生叫什么,但是我知道他的学号.我也可以通过学号找到这个同学.
图上这个是从左到右的一种排序,其实还有一种从右像左的排序,看下图:
这个查看和上边的一样,只不过是索引排序的方式不一样,他这次的排列序号是从右向左并且还是以-1开始,这里的-1其实就是表示我们的倒数第一个
-2表示倒数第二个,这样排列,如果我们的字符串比较长的时候想要获取最后一个就完全可以使用-1,看以下示例:
name = 'meet'
# 索引 -4-3-2-1
print(name[-1])
结果:
t
告诉大家一个小技巧,刚开始的我们不能明确的区分这个字符串中的每个索引的时候,我们就先把每个字母对应的索引写下来,这样就方便我们查找
上边我们说完了索引,你们就以为完事了是吗?不是滴,咱们还有来个内容没有进行讲解,分别是切片和步长
切片又是什么呢?我们先来看一个示例:
name = 'meet'
# 索引 0123
print(name[0:3])
结果:
mee
[第一个位置是开始:第二个位置是终止]中间必须使用分号,这样的写法就是从索引0开始获取到索引3结束
这个结果是不是和大家想的有点出入啊,大家肯定认为获取到的内容是meet,但是为什么是mee呢,因为 终止的索引是不包含的获取的是这个区间的内容
想想咱们在买肉的时候,有一个块整肉,这块整肉就后边有点肥,不想要是不是就让老板给切掉了,我们就买前边的部分啊.在生活中这种神操作就是切片
我也知道你们刚接过这些东西,使用起来不是很熟悉,尤其是切片这部分,在悄悄的告诉你们个小技巧,下次当看到切片中终止位置的时候把这个数减一就ok啦
步长又是什么呢?先看示例:
name = 'meet'
# 索引 0123
print(name[0:3:1])
结果:
mee
发现我在中括号中最后一个位置写了一个东西,也没什么变化,是的没有变化,因为我们不写的时候他默认就是1,我们换个数字在来看看
name = 'meet'
# 索引 0123
print(name[0:3:2])
结果:
me
这又是啥情况呢?想想我开始告诉大家的 中括号里第一个参数是起始位置,第二参数是终止位置,第三个参数现在告诉大家是步长(每次走几步)
当步长设置为2的时候,咱们只需要用起始位置0加上步长2,结果也就2然后在把索引为2的找到,2在加上步长2就是4,当要查找索引4是发现终止索引就是3,
所有不会进行查找.最终的结果就是me.
name = 'alex'
new_name = name.upper()
print(new_name)
# 把这个字符串全部变成大写
name = 'ALEX'
new_name = name.lower()
print(new_name)
# 把这个字符串全部变成小写
应用场景:
# 字符串大小写做验证码
y_z_m = 'O98k'
y_z_m_input = input("请输入验证码(O98k)")
user = input('请输入账号:')
pwd = input('请输入密码:')
if y_z_m == y_z_m_input:
if user == 'alex' and pwd == '8520':
print('登陆成功!')
else:
print('登录失败')
else:
print('验证码错误!')
name = 'alex'
new_name = name.startswith('a')
if new_name:
print('是以a开头')
# 判断这是不是字符串是不是以a开头的
name = 'alex'
new_name = name.startswith('e',2,5)
if new_name:
print('是以e开头')
# 我们可以指定从哪个位置开始哪个位置结束
name = 'alex'
new_name = name.endswith('x')
if new_name:
print('是以x结尾')
# 判断这是不是字符串是不是以x结尾的
name = 'alex'
new_name = name.endswith('x',2,5)
if new_name:
print('是以x结尾')
# 判断这是不是字符串是不是以x结尾的
name = 'alexdasx'
new_name = name.count('a')
print(new_name)
# 统计name这个字符串中a出现的次数
name = 'alexdasx'
new_name = name.replace('sx','sb',1)
print(new_name)
# 替换字符串中的内容以外 我们可以指定要替换的次数
name = ' alexdasx '
new_name = name.strip() # 默认去除的头尾两端的空格,换行符,制表符 也可以自己指定
print(new_name)
# 去除头尾俩遍的空格和换行符
name = 'alexdasx'
new_name = name.split("x") # 默认以空格,换行符,制表符分隔
print(new_name)
# 也可以通过x将字符串name进行切割
name = 'alexdasx'
new_name = name.split("x",maxsplit=1) # 默认以空格,换行符,制表符分隔
print(new_name)
# 切割后的内容是一个列表
name = 'alexdasx{}'
new_name = name.format('说的对')
print(new_name)
# 字符串格式化
# 可以按照顺序去填充,也可以按照索引去填充,也可以按照关键字填充
练习
将 name 变量对应的值中所有的"l"替换为 "p",并输出结果
将name变量对应的值中的第一个"l"替换成"p",并输出结果
将 name 变量对应的值根据所有的"l"进行分割,并输出结果。
将name变量对应的值根据第一个"l"分割,并输出结果。
请输出 name 变量对应的值的第2个字符?
请输出 name 变量对应的值的前3个字符?
请输出 name 变量对应的值的后2个字符?
判断是不是十进制的数字,返回的是布尔值
name = 'alexdasx'
new_name = name.isdecimal()
print(new_name)
# 判断是不是十进制的数字,返回结果是布尔值
判断是不是数字和字母以及中文,返回的是布尔值
name = 'alex7dasx'
new_name = name.isalnum()
print(new_name)
# 判断是不是数字和字母以及中文,返回结果是布尔值
判断是不是字母和汉字,返回的是布尔值
name = 'alexdasx'
new_name = name.isalpha()
print(new_name)
# 判断是不是纯字母和汉字,返回的是布尔值
练习
输??个字符串，要求判断在这个字符串中?写字?，?写字?，数字， 其它字符共出现了多少次，并输出
目前我们写的内容还比较少,如果有一个很长很长的字符串,要是一个一个数是不是很累呢,Python给咱们提供了一个方法就是获取长度的.
name = "Meet"
print(len(name))
结果:
4
这里需要大家清楚一点的就是,len是一个公共的方法,不是字符串的方法只有用字符串.的方式使用的才是字符串的方法
我们现在能够轻松的获取到到长度,现在我有这么一个字符串 name = "Meet",请使用while循环获取到字符串中每个元素并打印,效果图入下:
name = "Meet"
count = 0
while count < len(name):
print(name[count])
count = count + 1
以上这个写法是没有问题的,你们来看下边这个会不会简单些
name = "Meet"
for i in name:
print(i)
for i in "Meet":
print(i)
上边的这个东西叫做for循环, for是关键字 i是一个变量 后边的name是要被循环的内容,他会把这个name指向的字符串里的每个元素打印出来
for循环是可以循环的数据结构:
唯独不能进行循环的就是 整型(int)和布尔值(bool)
列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.
比如js中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用‘ , ‘隔开而且可以存放各种数据类型:
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,]]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，
32位python的限制是 536870912 个元素,
64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
lst = [1,2,3,"alex",[1,2,3]]
我们定义了一个列表,我们现在来看看内存中是怎样存储的
lst我们就可以想象成一个书包,书包中存放了衣服,电脑,书,钱包,钱包中放的是身份证,公交卡,家门钥匙
列表和字符串一样也拥有索引:
lst = ['刘德华','周润发','周杰伦','向华强']
print(lst[0]) # 列表中第一个元素
print(lst[1]) # 列表中第二个元素
print(lst[2]) # 列表中第三个元素
注意:列表是可以进行修改的,这里和字符串不一样
lst[3] = '王健林'
print(lst)
字符串修改
s = '王思聪'
s[0] = '李'
print(s)
结果:
Traceback (most recent call last):
File "D:/python_object/path2/test.py", line 1076, in <module>
s[0] = '李'
TypeError: 'str' object does not support item assignment
lst = ["麻花藤", "王剑林", "马芸", "周鸿医", "向华强"]
print(lst[0:3]) # ['麻花藤', '王剑林', '马芸']
print(lst[:3]) # ['麻花藤', '王剑林', '马芸']
print(lst[1::2]) # ['王剑林', '周鸿医'] 也有步长
print(lst[2::-1]) # ['马芸', '王剑林', '麻花藤'] 也可以倒着取
print(lst[-1:-3:-2]) # 倒着带步长
练习
li = [1, 3, 2, "a", 4, "b", 5,"c"]
通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通过对li列表的切片形成新的列表l5,l5 = ["c"]
通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
注意 list和str是不一样的. lst可以发生改变. 所以直接就在原来的对象上进行了操作
追加模式
lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]
print(lst)
lst.append("wusir")
print(lst)
练习
输入用户信息,添加到列表中
lst = []
while True:
content = input("请输入你要录入的员工信息, 输入Q退出:")
if content.upper() == 'Q':
break
lst.append(content)
print(lst)
插入模式
lst = ["麻花藤", "张德忠", "孔德福"]
lst.insert(1, "刘德华") # 在1的位置插入刘德华. 原来的元素向后移动一位
print(lst)
迭代添加
# 迭代添加
lst = ["王志文", "张一山", "苦海无涯"]
lst.extend(["麻花藤", "麻花不疼"])
print(lst)
pop 通过下标删除元素(默认删除最后一个)
lst = ["麻花藤", "王剑林林", "李李嘉诚", "王富贵"]
print(lst)
lst.pop()
deleted = lst.pop()
print('被删除的',deleted)
print(lst)
el = lst.pop(2) # 删除下标位2的元素
print(el) # 被删除的元素
print(lst)
remove 通过元素删除
lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
lst.remove('王剑林')
print(lst)
结果:
['麻花藤', '李嘉诚', '王富贵']
lst.remove('哈哈') # 删除不存在的元素
结果:
Traceback (most recent call last):
File "D:/python_object/path2/test.py", line 1115, in <module>
lst.remove('哈哈') # 删除不存在的元素
ValueError: list.remove(x): x not in list
clear 清空
lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
lst.clear()
print(lst)
结果:
[]
练习
写代码，有如下列表，按照要求实现每一个功能
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
请删除列表中的元素"ritian",并输出添加后的列表
请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
请删除列表中的第2至4个元素，并输出删除元素后的列表
索引切片修改
# 修改
lst = ["太白", "太黑", "五色", "银王", "?天"]
lst[1] = "太污" # 把1号元素修改成太污 print(lst)
lst[1:4:3] = ["麻花藤", "哇靠"] # 切片修改也OK. 如果步长不是1, 要注意元素的数
print(lst)
lst[1:4] = ["我是哪个村的村长王富贵"] # 如果切片没有步长或者步长是1. 则不用关心个数
print(lst)
列表是一个可迭代对象,所以可以进行for循环
lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
for i in lst:
print(i)
结果:
麻花藤
王剑林
李嘉诚
王富贵
练习
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
将列表li中第三个元素修改成'taibai'
将列表li中第四个元素修改成'女神'
将列表li中前三个元素修改成'alex1,alex2,alex3'
注意:采用降维操作,一层一层的看就好
lst = [1,'太白','wusir',['麻花疼',['可口可乐'],'王健林']]
# 找到wusir
print(lst[2])
# 找到太白和wusir
print(lst[1:3])
# 找到太白的白字
print(lst[1][1])
# 将wusir拿到,然后首字母大写 在扔回去
s = lst[2]
s = s.capitalize()
lst[2] = s
print(lst)
# 简写
lst[2] = lst[2].capitalize()
print(lst)
# 把太白换成太黑
lst[1] = lst[1].replace('白','黑')
# 把麻花疼换成麻花不疼
lst[3][0] = lst[3][0].replace('疼','不疼')
print(lst)
# 在可口可乐后边添加一个雪碧
lst[3][1].append('雪碧')
print(lst)
练习
写代码，有如下列表，按照要求实现每一个功能。
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写（用两种方式）。
将列表中的数字3变成字符串"100"（用两种方式）。
将列表中的字符串"1"变成数字101（用两种方式）。
这个知识点用在什么地方:
你需要存储大量的数据，且需要这些数据有序的时候。制定一些特殊的数据群体：按顺序，按规则，自定制设计数据
1.对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。
元祖:俗称不可变的列表,又被成为只读列表,元祖也是python的基本数据类型之一,
用小括号括起来,里面可以放任何数据类型的数据,查询可以,循环也可以,切片也可以.但就是不能改.在python中关键字是tuple
tu = ('我','怎么','这么','可爱')
tu1 = tu[0] # 记性下标
print(tu1)
for i in tu:
print(i) # 进行for循环
tu2 = tu[0:3]
print(tu2) # 进行切片
结果:
Traceback (most recent call last):
File "D:/python_object/path2/test.py", line 1286, in <module>
tu[0] = '你'
NameError: name 'tu' is not defined
关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象.
元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组
tu = ('meet')
print(type(tu)) #type是查看数据类型
结果:
<class:str>
tu = ('meet',)
print(type(tu)) #type是查看数据类型
结果:
<class:tuple>
这个知识点如何使用
1.可遍历
2.可切片
3.有len,count,index方法
tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱','小姨子低声说道说和姐夫还提钱'))
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
print(tu1)
print(tu2)
print(tu3)
print(tu4)
结果:
今天姐姐不在家
姐夫和小姨子在客厅聊天
姐夫问小姨子税后多少钱
小姨子低声说道说和姐夫还提钱
在哪里使用
就是将一些非常重要的不可让人改动的数据放在元祖中，只供查看。后期你们写项目的时候会有配置文件,配置文件中的不想让人修改的单个变量使用常量,如果是多个不想让人修改的就是用元组来存储
翻译过来就是范围,那我们我来先看下.
range(0,5,1)
参数第一个是范围的起始位置
参数第二个是范围的结束位置
参数第三个是步长
print(range(0,5))
# 结果:
range(0, 5) #一个范围
# 我们可以通过list方法来转换这个范围来查看一下
l = list(range(0,5))
print(l)
# 结果:
[0, 1, 2, 3, 4]
l = list(range(0,5,2))
print(l)
# 结果:
[0, 2, 4] # 这个结果就会发现和我之前用步长获取的内容是相似的,是的他就是步长
练习
利用for循环和range打印出下面列表的索引。
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
利用for循环和range找出100以内所有的偶数并将这些偶数插入到一个新列表中
利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中
利用for循环和range从100~1，倒序打印
利用for循环和range，将1-30的数字一次添加到一个列表中，并循环这个列表，将能被3整除的数改成*。
语法:{'key1':1,'key2':2}
/
# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美?'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key
dic = {}
dic['name'] = '汪峰'
dic['age'] = 18
print(dic)
结果:
{'name': '汪峰', 'age': 18}
# 如果dict中没有出现这个key,就会将key-value组合添加到这个字典中
# 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值
s1 = dic.setdefault('王菲')
print(s1)
print(dic)
结果:
None
# 返回的是添加进去的值
{'王菲': None}
# 我们使用setdefault这个方法 里边放的这个内容是我们字典的健,这样我们添加出来的结果
就是值是一个None
dic.setdefault('王菲',歌手)
# 这样就是不会进行添加操作了,因为王菲在dic这个字典中存在
# 总结: 当setdefault中第一个参数存在这个字典中就就不进行添加操作,否则就添加
dic1 = {}
s2 = dic1.setdefault('王菲','歌手')
print(s2)
print(dic1)
结果:
歌手
{'王菲': '歌手'}
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
s = dic.pop('哈啥给') # pop删除有返回值,返回的是被删的值
print(s)
print(dic) # 打印删除后的字典
dic.popitem() # 随机删除 python3.6是删除最后一个
print(dic)
dic.clear() # 清空
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
dic['哈啥给'] = '剑姬' # 当哈哈给是字典中的健这样写就是修改对应的值,如果不存在就是添加
print(dic)
dic.update({'key':'v','哈啥给':'剑姬'})
# 当update中的字典里没有dic中键值对就添加到dic字典中,如果有就修改里边的对应的值
print(dic)
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
s = dic['大宝剑'] #通过健来查看,如果这个健不在这个字典中.就会报错
print(s)
s1 = dic.get('剑圣') #通过健来查看,如果这个健不在这个字典中.就会返回None
print(s1)
s2 = dic.get('剑姬','没有还查你是不是傻') # 我们可以在get查找的时候自己定义返回的结果
print(s2)
练习
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
请在k3对应的值中追加一个元素 44，输出修改后的字典
请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
key_list = dic.keys()
print(key_list)
结果:
dict_keys(['剑圣', '哈啥给', '大宝剑'])
# 一个高仿列表,存放的都是字典中的key
value_list = dic.values()
print(value_list)
结果:
dict_values(['易', '剑豪', '盖伦'])
#一个高仿列表,存放都是字典中的value
key_value_list = dic.items()
print(key_value_list)
结果:
dict_items([('剑圣', '易'), ('哈啥给', '剑豪'), ('大宝剑', '盖伦')])
# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值
练习
循环打印字典的值
循环打印字典的键
循环打印元祖形式的键值对
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic:
print(i)
for i in dic.keys():
print(i)
循环打印字典中的键
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic:
print(dic[i])
for i in dic.values():
print(i)
循环打印字典中的值和值
dic = {'剑圣':'易','哈啥给':'剑豪','大宝剑':'盖伦'}
for i in dic.items():
print(i)
循环打印元祖形式的键值对
a,b = 1,2
print(a,b)
结果:
1 2
a,b = ('你好','世界')
print(a,b)
结果:
你好 世界
a,b = ['你好','大飞哥']
print(a,b)
结果:
你好 世界
a,b = {'汪峰':'北京北京','王菲':'天后'}
print(a,b)
结果:
汪峰 王菲
解构可以将内容分别赋值到变量当中,我们使用解构就能够快速的将值使用
for k,v in dic.items():
print('这是键',k)
print('这是值',v)
结果:
这是键 剑圣
这是值 易
这是键 哈啥给
这是值 剑豪
这是键 大宝剑
这是值 盖伦
dic = {
'name':'汪峰',
'age':48,
'wife':[{'name':'国际章','age':38}],
'children':['第一个熊孩子','第二个熊孩子']
}
获取汪峰的妻子名字
d1 = dic['wife'][0]['name']
print(d1)
获取汪峰的孩子们
d2 = dic['children']
print(d2)
获取汪峰的第一个孩子
d3 = dic['children'][0]
print(d3)
练习
dic1 = {
'name':['alex',2,3,5],
'job':'teacher',
'oldboy':{'alex':['python1','python2',100]}
}
1，将name对应的列表追加?个元素’wusir’。
2，将name对应的列表中的alex?字??写。
3，oldboy对应的字典加?个键值对’?男孩’,’linux’。
4，将oldboy对应的字典中的alex对应的列表中的python2删除
我们前期的时候和大家说了,有些方法我们放在数据类型补充的这一天中,我们今天将前面没有讲解的内容,都一起讲解了,就现从str开始
1.1 首字母大写
name = "meet"
name.capitalize()
1.2 每个单词的首字母大写
name = "meet"
name.title()
1.3 大小写反转
name = "meet"
name.swapcase()
1.4 统计
name = "meet"
name.count()
1.5 查找
name = "meet"
name.find()
1.6 居中
name = "meet"
name.index()
1.1 反转
lst = [1,2,3,4,5]
lst.reverse()
1.2 排序
lst = [1,2,3,4,5]
lst.sort() # 升序
lst.sort(reverse=True) # 降序
1.3 查找
lst = [1,2,3,4,5]
lst.finde(3) # 存在返回索引,不存在就返回-1
lst.index(3) # 存在就返回索引,不存在就报错
1.4 统计
lst = [1,23,4,5,6,]
lst.count(23) # 统计23出现的次数
1.1 随机删除
dic = {"key":"value","key2":"value2"}
dic.popitem() # 随机删除
1.2 批量创建字典
dic = {}
dic1 = dic.fromkeys("abc",[1,2])
print(dic1)
formkeys这个是个坑,坑点就在于值是可变数据类型的时候,当第一个键对应的值进行修改了以后,其余的键对应的值也都跟着进行改变了. 如何避免坑,就是批量创建字典的时候值不能使用可变的数据类型.
最后我们对我们学习的这些数据类型进行一个总结,我们按照有序,无序,可变,不可变,取值方式来总结
元组 => 列表 list(tuple)
列表 => 元组 tuple(list)
list=>str str.join(list)
str=>list str.split()
转换成False的数据:
0,'',None,[],(),{},set() ==> False
lst = [1,2,3,4,5,6]
for i in lst:
lst.append(7) # 这样写法就会一直持续添加7
print(lst)
print(lst)
列表: 循环删除列表中的每?个元素
li = [11, 22, 33, 44]
for e in li:
li.remove(e)
print(li)
结果:
[22, 44]
分析原因: for的运?过程. 会有?个指针来记录当前循环的元素是哪?个, ?开始这个指针指向第0 个.
然后获取到第0个元素. 紧接着删除第0个. 这个时候. 原来是第?个的元素会?动的变成 第0个.
然后指针向后移动?次, 指向1元素. 这时原来的1已经变成了0, 也就不会被删除了.
?pop删除试试看:
li = [11, 22, 33, 44]
for i in range(0, len(li)):
del li[i]
print(li)
结果: 报错
# i= 0, 1, 2 删除的时候li[0] 被删除之后. 后??个就变成了第0个.
# 以此类推. 当i = 2的时候. list中只有?个元素. 但是这个时候删除的是第2个 肯定报错啊
经过分析发现. 循环删除都不?. 不论是?del还是?remove. 都不能实现. 那么pop呢?
for el in li:
li.pop() # pop也不?
print(li)
结果:
[11, 22]
只有这样才是可以的:
for i in range(0, len(li)): # 循环len(li)次, 然后从后往前删除
li.pop()
print(li)
或者. ?另?个列表来记录你要删除的内容. 然后循环删除
li = [11, 22, 33, 44]
del_li = []
for e in li:
del_li.append(e)
for e in del_li:
li.remove(e)
print(li)
注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另?个集合中然后再批量删除.
dict中的fromkey(),再次重提 可以帮我们通过list来创建?个dict
dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])
print(dic)
结果:
{'jay': ['周杰伦', '麻花藤'], 'JJ': ['周杰伦', '麻花藤']}
代码中只是更改了jay那个列表. 但是由于jay和JJ?的是同?个列表. 所以. 前?那个改了. 后面那个也会跟着改
dict中的元素在迭代过程中是不允许进?删除的
dic = {'k1': 'alex', 'k2': 'wusir', 's1': '??板'}
# 删除key中带有'k'的元素
for k in dic:
if 'k' in k:
del dic[k] # dictionary changed size during iteration, 在循环迭
代的时候不允许进?删除操作
print(dic)
那怎么办呢? 把要删除的元素暂时先保存在?个list中, 然后循环list, 再删除
dic = {'k1': 'alex', 'k2': 'wusir', 's1': '??板'}
dic_del_list = []
# 删除key中带有'k'的元素
for k in dic:
if 'k' in k:
dic_del_list.append(k)
for el in dic_del_list:
del dic[el]
print(dic)
编码回顾:
ASCII : 最早的编码. ??有英??写字?, ?写字?, 数字, ?些特殊字符. 没有中?, 8个01代码, 8个bit, 1个byte
GBK: 中?国标码, ??包含了ASCII编码和中?常?编码. 16个bit, 2个byte
UNICODE: 万国码, ??包含了全世界所有国家?字的编码. 32个bit, 4个byte, 包含了 ASCII
UTF-8: 可变?度的万国码. 是unicode的?种实现. 最?字符占8位 1.英?: 8bit 1byte 2.欧洲?字:16bit 2byte 3.中?:24bit 3byte
综上, 除了ASCII码以外, 其他信息不能直接转换. 在python3的内存中. 在程序运?阶段. 使?的是unicode编码. 因为unicode是万国码. 什么内容都可以进?显?. 那么在数据传输和存储的时候由于unicode比较浪费空间和资源. 需要把 unicode转存成UTF-8或者GBK进?存储. 怎么转换呢. 在python中可以把?字信息进?编码. 编码之后的内容就可以进?传输了. 编码之后的数据是bytes类型的数据.其实啊. 还是原来的 数据只是经过编码之后表现形式发?了改变?已.
bytes的表现形式:
s = "alex"
print(s.encode("utf-8")) # 将字符串编码成UTF-8
print(s.encode("GBK")) # 将字符串编码成GBK
结果:
b'alex'
b'alex'
s = "中"
print(s.encode("UTF-8")) # 中?编码成UTF-8
print(s.encode("GBK")) # 中?编码成GBK
结果:
b'\xe4\xb8\xad'
b'\xd6\xd0'
记住: 英?编码之后的结果和源字符串?致. 中?编码之后的结果根据编码的不同. 编码结果也不同. 我们能看到. ?个中?的UTF-8编码是3个字节. ?个GBK的中?编码是2个字节. 编码之后的类型就是bytes类型. 在?络传输和存储的时候我们python是保存和存储的bytes 类型. 那么在对?接收的时候. 也是接收的bytes类型的数据. 我们可以使?decode()来进?解 码操作. 把bytes类型的数据还原回我们熟悉的字符串:
s = "我叫李嘉诚"
print(s.encode("utf-8")) #
b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'
print(b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'.decod
e("utf-8")) # 解码
编码和解码的时候都需要制定编码格式.
s = "我是?字" bs = s.encode("GBK")
# 我们这样可以获取到GBK的?字
# 把GBK转换成UTF-8
# ?先要把GBK转换成unicode. 也就是需要解码
s = bs.decode("GBK") # 解码
# 然后需要进?重新编码成UTF-8
bss = s.encode("UTF-8") # 重新编码
print(bss)
## 第七章
我们前期的时候和大家说了,有些方法我们放在数据类型补充的这一天中,我们今天将前面没有讲解的内容,都一起讲解了,就现从str开始
1.1 首字母大写
name = "meet"
name.capitalize()
1.2 每个单词的首字母大写
name = "meet"
name.title()
1.3 大小写反转
name = "meet"
name.swapcase()
1.4 统计
name = "meet"
name.count()
1.5 查找
name = "meet"
name.find()
1.6 居中
name = "meet"
name.index()1.1 反转
lst = [1,2,3,4,5]
lst.reverse()1.2 排序
lst = [1,2,3,4,5]
lst.sort() # 升序
lst.sort(reverse=True) # 降序1.3 查找
lst = [1,2,3,4,5]
lst.finde(3) # 存在返回索引,不存在就返回-1
lst.index(3) # 存在就返回索引,不存在就报错1.4 统计
lst = [1,23,4,5,6,]
lst.count(23) # 统计23出现的次数1.1 随机删除
dic = {"key":"value","key2":"value2"}
dic.popitem() # 随机删除1.2 批量创建字典
dic = {}
dic1 = dic.fromkeys("abc",[1,2])
print(dic1)formkeys这个是个坑,坑点就在于值是可变数据类型的时候,当第一个键对应的值进行修改了以后,其余的键对应的值也都跟着进行改变了. 如何避免坑,就是批量创建字典的时候值不能使用可变的数据类型.
最后我们对我们学习的这些数据类型进行一个总结,我们按照有序,无序,可变,不可变,取值方式来总结
元组 => 列表 list(tuple)
列表 => 元组 tuple(list)
list=>str str.join(list)
str=>list str.split()
转换成False的数据:
0,'',None,[],(),{},set() ==> False
lst = [1,2,3,4,5,6]
for i in lst:
lst.append(7) # 这样写法就会一直持续添加7
print(lst)
print(lst)
列表: 循环删除列表中的每?个元素
li = [11, 22, 33, 44]
for e in li:
li.remove(e)
print(li)
结果:
[22, 44]
分析原因: for的运?过程. 会有?个指针来记录当前循环的元素是哪?个, ?开始这个指针指向第0 个.
然后获取到第0个元素. 紧接着删除第0个. 这个时候. 原来是第?个的元素会?动的变成 第0个.
然后指针向后移动?次, 指向1元素. 这时原来的1已经变成了0, 也就不会被删除了.
?pop删除试试看:
li = [11, 22, 33, 44]
for i in range(0, len(li)):
del li[i]
print(li)
结果: 报错
# i= 0, 1, 2 删除的时候li[0] 被删除之后. 后??个就变成了第0个.
# 以此类推. 当i = 2的时候. list中只有?个元素. 但是这个时候删除的是第2个 肯定报错啊
经过分析发现. 循环删除都不?. 不论是?del还是?remove. 都不能实现. 那么pop呢?
for el in li:
li.pop() # pop也不?
print(li)
结果:
[11, 22]
只有这样才是可以的:
for i in range(0, len(li)): # 循环len(li)次, 然后从后往前删除
li.pop()
print(li)
或者. ?另?个列表来记录你要删除的内容. 然后循环删除
li = [11, 22, 33, 44]
del_li = []
for e in li:
del_li.append(e)
for e in del_li:
li.remove(e)
print(li)
注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另?个集合中然后再批量删除.
dict中的fromkey(),再次重提 可以帮我们通过list来创建?个dict
dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])
print(dic)
结果:
{'jay': ['周杰伦', '麻花藤'], 'JJ': ['周杰伦', '麻花藤']}
代码中只是更改了jay那个列表. 但是由于jay和JJ?的是同?个列表. 所以. 前?那个改了. 后面那个也会跟着改
dict中的元素在迭代过程中是不允许进?删除的
dic = {'k1': 'alex', 'k2': 'wusir', 's1': '??板'}
# 删除key中带有'k'的元素
for k in dic:
if 'k' in k:
del dic[k] # dictionary changed size during iteration, 在循环迭
代的时候不允许进?删除操作
print(dic)
那怎么办呢? 把要删除的元素暂时先保存在?个list中, 然后循环list, 再删除
dic = {'k1': 'alex', 'k2': 'wusir', 's1': '??板'}
dic_del_list = []
# 删除key中带有'k'的元素
for k in dic:
if 'k' in k:
dic_del_list.append(k)
for el in dic_del_list:
del dic[el]
print(dic)编码回顾:
ASCII : 最早的编码. ??有英??写字?, ?写字?, 数字, ?些特殊字符. 没有中?, 8个01代码, 8个bit, 1个byte
GBK: 中?国标码, ??包含了ASCII编码和中?常?编码. 16个bit, 2个byte
UNICODE: 万国码, ??包含了全世界所有国家?字的编码. 32个bit, 4个byte, 包含了 ASCII
UTF-8: 可变?度的万国码. 是unicode的?种实现. 最?字符占8位 1.英?: 8bit 1byte 2.欧洲?字:16bit 2byte 3.中?:24bit 3byte
综上, 除了ASCII码以外, 其他信息不能直接转换. 在python3的内存中. 在程序运?阶段. 使?的是unicode编码. 因为unicode是万国码. 什么内容都可以进?显?. 那么在数据传输和存储的时候由于unicode比较浪费空间和资源. 需要把 unicode转存成UTF-8或者GBK进?存储. 怎么转换呢. 在python中可以把?字信息进?编码. 编码之后的内容就可以进?传输了. 编码之后的数据是bytes类型的数据.其实啊. 还是原来的 数据只是经过编码之后表现形式发?了改变?已.
bytes的表现形式:
s = "alex"
print(s.encode("utf-8")) # 将字符串编码成UTF-8
print(s.encode("GBK")) # 将字符串编码成GBK
结果:
b'alex'
b'alex'
s = "中"
print(s.encode("UTF-8")) # 中?编码成UTF-8
print(s.encode("GBK")) # 中?编码成GBK
结果:
b'\xe4\xb8\xad'
b'\xd6\xd0'记住: 英?编码之后的结果和源字符串?致. 中?编码之后的结果根据编码的不同. 编码结果也不同. 我们能看到. ?个中?的UTF-8编码是3个字节. ?个GBK的中?编码是2个字节. 编码之后的类型就是bytes类型. 在?络传输和存储的时候我们python是保存和存储的bytes 类型. 那么在对?接收的时候. 也是接收的bytes类型的数据. 我们可以使?decode()来进?解 码操作. 把bytes类型的数据还原回我们熟悉的字符串:
s = "我叫李嘉诚"
print(s.encode("utf-8")) #
b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'
print(b'\xe6\x88\x91\xe5\x8f\xab\xe6\x9d\x8e\xe5\x98\x89\xe8\xaf\x9a'.decod
e("utf-8")) # 解码编码和解码的时候都需要制定编码格式.
s = "我是?字" bs = s.encode("GBK")
# 我们这样可以获取到GBK的?字
# 把GBK转换成UTF-8
# ?先要把GBK转换成unicode. 也就是需要解码
s = bs.decode("GBK") # 解码
# 然后需要进?重新编码成UTF-8
bss = s.encode("UTF-8") # 重新编码
print(bss)标签：ack lam UNC 1年 知乎 土豆 app spl 回收机制
原文地址：https://www.cnblogs.com/bky20061005/p/12121483.html
