一 Python初识
1 Python的历史
Python的历史python是蟒蛇的含义
python是一种解释型的,面向对象的,带有动态语义的高级程序设计语言.
python是一种使你在编程时能够保持自己的风格的程序设计语言,你不用费什么劲就可以实现你想要的功能,并且编写的程序清晰易懂.
python简史
诞生于1989年,python开发者guido,当时还在开发另外一种语言abc语言,abc语言主要是用于做数学运算和做物理运算的研究人员使用.
在1989年的圣诞节,他在阿姆斯特丹.在他闲着没事的时候他想开发一个插件来辅助abc语言实现相关功能,但是实际上他开发出的是一种脚本语言,
当他把这个脚本语言开发完成之后,发现它本身功能很强大,在他看来有很灵活易用,于是他已自己的名义发布了这门语言.现在就职于google.
python名字的由来:guido本人是天空马戏团(monty python)的忠实粉丝,于是他选择这给他开发的这种语言叫python.
2 Python的发展
第一阶段:CNRI时期 ,CNRI(罗伯特.卡恩1986年创立的美国全国研究创新联合会)是资助python发展初期的重要单位,
python1.5版本之前的成果大部分都在此时期完成
第二阶段:BeOpen时期,Guido Ven Rossum与BeOpen公司合作,此期间将Python2.0推出,甚至python1.6也同时问世,但原则上已经分别维护.
(至于推出2.0同时还推出1.6,这是因为python版本的问题,它是一门新兴的语言, 在89年的时候刚刚诞Th,
有很多功能在初期还不是很完善,但是后期完善的时候发现当前完善的体系已经完全不同于之前的设计,
所以python就会推出一个新的版本,当时就推出了2.0,实际上2.0和1.6是有很大区别的,使用上也不完全一样)
第三阶段:DC时期,当时Guido已经离开了BeOpen公司,将开发团队带到了Digital Creations(DC)公司,
该公司以发展Zope系统闻名,因此这项合作也颇受瞩目.
python 3.0 还没有被投放到市场,预计web3.0时代,建议使用python2.0
python目前成就
python获得年度Tiobe编程语言大奖
Tiobe编程语言排行榜:根据互连网上有经验的程序员,课程和第三方厂商的数量,并使用搜索引擎(如google,yahoo)以及
Amazon,youtube等统计出的排名数据,只反映某种语言的热门程度,并不说明语言的好不好,或者一门语言所编写的数量多少.
3 python的特征
python编程语言中的定位脚本语言
高阶动态编程语言
简单易学
python是一种代表简单主义思想的语言,python的这种伪代码本质是它最大的优点之一.
它使你能够专注于解决问题而不是去搞明白语言本身.python有极其简单的语法,极易上手.
解释性和编译性
python语言写的程序不需要编译成二进制代码,可以直接从源代码运行程序,
但是需要解释器,这点类似于java,或者matlab.
python中亦有编译执行的特性
可移植性
由于它的开源本质,python已经被移植到许多平台上.
丰富的库
丰富的库,似乎已成为判断一门是否强大的重要标准.python的标准库确实很庞大.
它可以帮助你处理各种工作,包括正则表达式,文档Th成,单元测试, 线程,数据库,网页浏览器,
CGI,FTP,电子邮件,XML,XML-RPC,HTML,WAV文件,密码系统,GUI(图形用户界面),TK和其他与系统有关的操作.
只要安装了python.所有这些功能都是可用的,这被称作python的"功能齐全"理念.
除了标准库以外,还有其他高质量的库,(似乎可以称作第三方),如wxpython twisted和python图形库等等.
python的特征
易用与速度的完美结合
把精力放在解决问题上
跨平台又易扩展
自动化的内存管理
内建许多高阶而实用的资料形态
轻易结合网络程序模块
万能钥匙？（胶水作用！可以轻易融合其他语言）
3 python的应用
google实现web爬虫和搜索引擎中的很多组件yahoo使用它（还有其他技术）管理讨论组
NASA 在他的几个系统中既用python开发，又将其作为脚本语言
youtube 视频分享服务大部分是python编写的
python语言的缺点
很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。
而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。
（对很多用户而言这也不算是限制）
⑴运行速度，有速度要求的话，用C++改写关键部分吧。
不过对于用户而言，机器上运行速度是可以忽略的。因为用户根本感觉不出来这种速度的差异。
⑵既是优点也是缺点，python的开源性是的Python语言不能加密， 但是目前国内市场纯粹靠编写软件卖给客户的越来越少，
网站和移动应用不需要给客户源代码，所以这个问题就是问题了。国随着时间的推移，很多国内软件公司，尤其是游戏公司，也开始规模使用他。
⑶ 构架选择太多（没有像C#这样的官方.net构架，也没有像ruby由于历史较短，构架开发的相对集中。
Ruby on Rails 构架开发中小型web程序天下无敌）。不过这也从另一个侧面说明，python比较优秀，吸引的人才多，项目也多。
二 Python环境部署
a) 下载源代码python-3.6.6版本,解压安装
ubuntu安装：
sudo apt update
sudo apt install python3
sudo apt install openssl
sudo apt install python3-pip
python3 --version
下载anaconda:
Anaconda指的是一个开源的Python发行版本，其包含了conda、Python 等180多个科学包及其依赖项。
因为包含了大量的科学包， Anaconda 的下载文件比较大（约 531 MB），如果只需要某些包，
或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）
Conda是一个开源的包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖，
并能够在不同的环境之间切换
//anaconda的官网:
https://www.anaconda.com/download/success
下载linux版本的或者windows版本的
下载好之后，拷贝到linux下面
cp /mnt/hgfs/porting_env/python/Anaconda3-2024.02-1-Linux-x86_64.sh ./
bash Anaconda3-2024.02-1-Linux-x86_64.sh
>>> yes //输入yes并敲回车
Do you accept the license terms? [yes|no]
>>> yes //输入yes并敲回车
Anaconda3 will now be installed into this location:
/home/andy/anaconda3
-- Press ENTER to confirm the location
- - Press CTRL-C to abort the installation
- - Or specify a different location below
//此处就使用默认的安装位置即可
[/home/andy/anaconda3] >>>
You can undo this by running `conda init --reverse $SHELL`? [yes|no]
[no] >>> yes //输入yes即可看到安装完成!
安装完成之后, source ~/.bashrc
此时发现, 命令行的提示符变为了 (base) anaconda3！
如果希望 conda 的基础环境在启动时不被激活，请将 auto_activate_base 参数设置为 false：
conda config --set auto_activate_base false
想要再次进入conda的base环境，只需要使用对应的conda指令
conda activate base
进入anaconda的安装目录:
cd /home/andy/anaconda3
执行 conda list 可以看到anaconda的安装的包.
conda env list //可以看到conda的环境变量列表
b） 安装ipython
anaconda安装完成后可以用pip命令安装相应的包,可以用conda安装软件
ipython IPython与Python的主要区别在于IPython是一个增强版本的交互式解释器，
提供了更加丰富的功能和工具，适用于更为高效和便捷的交互式编程和数据科学应用
pip install ipython
安装完成ipython 之后，在终端输入ipython 即可进入ipython的命令行:
使用：
In [1]: print("hello")
hello
注意：命令行的间隔比较长，可以进行调整：
输入doc+Tab键，即可切换到python的模式
conda install ipython
三 python的基本使用
3.0 说在前面的话：
python的注释：
单行注释: #
多行注释：三个单引号''' 或者三个双引号"""
>>> """bala
... bala
... bala"""
'bala\nbala\nbala'
>>>
>>>
>>> '''bala
... bala
... bala
... '''
函数：一般在python中也叫方法, 函数定义者是实现功能的，函数调用者是使用功能的
print（数据） #将小括号中的内容显示在控制台中
变量 = input ("需要显示的内容") #将用户输入的数据赋值给函数
>>> name = input ("请输入您的名字:")
请输入您的名字:熏悟空
>>> age = input ("请输入您的年龄:")
请输入您的年龄:519
>>> print (name + "的年龄是:" + age + '.')
熏悟空的年龄是:519.
注意： print 和input都属于python的内建函数, 都属于builtins.py，可以通过help('butiltins')进行查看
就像C、C++的man手册一样，哪个不会查哪个就可以了
python的交互式解释器(直接在终端输入python3即可进入):
>>> print ("hello world")
hello world
>>> exit () #退出python解释器
python的文本模式(非交互式)
编写python脚本时可以直接用vim,脚本扩展名惯例为.py结尾
vim 00test.py
#!/usr/bin/python
print ("hello world!");
python 00test.py
Python的文件类型
源代码:
python源代码的文件以'py | python'为扩展名,由python程序解释,不需要编译;
字节代码：
python源文件经编译后生成扩展名为"pyc"的文件
编译方法 import py_compile
py_compile.compile("00test.py")
vi 02compile.py
#!/usr/bin/python3
import py_compile
py_compile.compile("00test.py");
python3 02compile.py
python3#ls
00test.py 01test.python 02compile.py anaconda __pycache__
会发现多了一个__pycache__的目录
python3#ls __pycache__/
00test.cpython-310.pyc
为了提高模块加载的速度，
每个模块都会在__pycache__文件夹中放置该模块的预编译模块，
命名为module.version.pyc,version是模块的预编译版本编码，一般都包含Python的版本号。
例如在CPython 发行版3.4中，fibo.py文件的预编译文件就是：__pycache__/fibo.cpython-34.pyc。
这种命名规则可以保证不同版本的模块和不同版本的python编译器的预编译模块可以共存。
脚本在运行之前会首先检查python文件的最后编辑日期和预编译模块的编译时间，
从而决定是否需要重新编译。预编译模块也是跨平台的，所以不同的模块是可以在不同的系统和不同的架构之间共享的。
为什么会出现__pycache__文件夹？
python解释器会将 *.py 脚本文件进行编译，并将编译结果保存到__pycache__目录中。
下次再执行工程时，若解释器发现这个 *.py 脚本没有修改过，就会跳过编译这一步，
直接运行以前生成的保存在 __pycache__文件夹里的 *.pyc 文件。
这样工程较大时就可以大大缩短项目运行前的准备时间；如果你只需执行一个小工程，没关系 忽略这个文件夹就行。
附：该文件夹出现在Python3.2及其后的版本中，Python2下的编译文件和源文件放同目录。
Python在两种情况下不检查缓存。第一种，从命令行中直接加载的模块总是会重新编译并且结果不保存。
第二种，如果没有源模块，则不会检查缓存。
为了支持无源代码的部署方式，应该将预编译模块放在源代码文件夹中而不是__pycache__中，
并且不要包含源代码模块
优化代码 //了解
经过优化的源文件,扩展名为".pyo"
python3 -O -m py_compile 00test.py
python3#ls __pycache__/
00test.cpython-310.opt-1.pyc 00test.cpython-310.pyc
注：python文档是这样描述的：这个优化没有多大作用，只是移除了断言。
至于速度，运行几乎一样。
.opt-1.pyc和.pyc文件的执行速度不会比.py文件快，快的地方在于模块加载的速度。
compileall模块可以用来把某个文件夹的中的所有文件都编译成为.pyc或者.pyo文件。
mkdir 03test
cp ../00test.py ./
cp ../01test.python ./
cat 04new.py
#!/bin/env python3
import compileall
compileall.compile_dir("./03test")
练习：
创建目录dir
在dir写一个 python脚本 输出 hello 通过py_compile编译该脚本
在dir下写一个python 脚本 输出 wold
再写一个python脚本输出ok
将dir目录下所有的脚本编译 compileall
mkdir 05dir
cd 05dir/
cat 00test.py
#!/usr/bin/python3
print ("hello");
import py_compile
py_compile.compile("00test.py")
cat 01test.py
#!/bin/env python3
print ("world");
cat 02test.py
#!/usr/bin/python3
print("ok");
cat 04compileall.py
#!/usr/bin/python3
import compileall
compileall.compile_dir("../05dir")
四 Python的数据类型
程序运行时需要处理的数据类型分为两大类
数字型：
整数、浮点数、复数
int float bool complex
字符串型、list、tuple 元组、dictionary 字典
>>> num0=100
>>> num1=0o10
>>> num2=0x16
>>> num3=3.14
>>> num4=3.14E-2 #等价于0.0314
python内部内置的bool类型的常量
True, 1 真
False,0 假
>>> result = input("请输入您的职业:") == "高工" #输入高工为True，否则为False
请输入您的职业:高工
>>> result
True
五 Python中的变量
Python的变量
python中用=表示赋值运算
变量是计算机内存中的一块区域,
变量可以存储规定范围内的值,而且值是可以改变的.
很多语言中声明变量要先声明变量的类型,比如c语言.在python也一样
注意：python的变量名没有类型 变量有类型 和c语言等不同
变量的命名
变量名有字母,数字,下划线组成.
数字不能开头
不可以使关键字(比如help python等)
如 a a1 a_ a_1
>>> help("keywords");
Here is a list of the Python keywords. Enter any keyword to get more help.
False class from or
None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not
语法：
变量名=数据
变量名1=变量名2=数据
变量名1，变量名2= 数据1，数据2
创建变量：
>>> #创建变量
>>> name01 = "孙悟空"
>>> name02 = "唐僧"
>>> name03 = name01 + name02
>>> #修改变量
>>> name01 = "悟空"
>>> print(name03)
孙悟空唐僧
>>> #变量赋值变量
>>> name04=name01
>>> print(name04)
悟空
删除变量：
>>> name01 = "悟空"
>>> name02=name01
>>> del name01, name02
del, 用于删除变量, 同时解除与对象的关联，如果可能则释放对象
每个对象记录被变量绑定（引用）的数量，当为0时被销毁
注意：在python中变量没有数据类型，但是关联的对象有数据类型!
>>> a = 100
>>> print (type(a))
<class 'int'>
>>> a = 3.14
>>> print (type(a))
<class 'float'>
多重赋值
>>> x=y=1
增量赋值
>>> x=x+1
多元赋值:
>>> x=y=z=1
变量交换方式:
1) 方式一 2) 方式二 3）方式三
>>> x=1 >>> x=1 >>> x=1
>>> y=2 >>> y=2 >>> y=2
>>> tmp=x >>> x,y=y,x >>> x=x+y
>>> x=y >>> y=x-y
>>> y=tmp >>> x=x-y
python的内存分配
作为一个负责任的程序员,我们知道为变量分配内存时,
是在借用系统资源,在用完之后,应该释放借用的系统资源,
Python解释器承担了内存管理的复杂任务,这大大简化了应用程序的编写,
你只需要关心你要解决的问题,至于底层的事情放心交给python解释器去做就行了
变量的引用
>>> a=123
>>> a
123
>>> a=456
>>> a
456
上边试验我们可以看出a被重新赋值了,也许有的人理解为a就是一个盒子
123和456就是在盒子里存储的内容,将123删除在赋值456,实际上python不是这样处理的,
123和456都存在内存里,a不过是一个引用的名字,python是以数据为主
如:
>>> a=123
>>> id(a) #使用id函数查看a在内存中的地址
127606857240624
>>> a=456
>>> id(a) #使用id函数查看a在内存中的地址
127606781631888
>>> #两次的地址不一样，说白了变量a只是数据的引用
一条数据可能多个标签
>>> a=123
>>> b=123
>>> id(a)
127606857240624
>>> id(b)
127606857240624
>>> #虽然变量的名字不同,但是他们引用的数据是同一个所以内存空间是相同的!
>>> #这和C/C++语言有本质上的区别
练习:
1.创建一个变量,并给它赋一个数值(任何数值都行),然后使用print显示变量
>>> a=100
>>> print(a)
100
2.改变这个变量,可以用一个新值替换原来的值,或者将原来的值增加某个量.使用print显示这个新值
>>> a=100+200
>>> print(a)
300
3.创建另一个变量.并赋给它一个字符串(某个文本).然后用print显示这个变量
>>> a="hello"
>>> print(a)
hello
4.在交互模式中让python计算一周有多少分钟,不过,这次要使用变量.
以DaysPerWeek HoursPerDay MinutePerHour 为变量名创建变量然后将它们相乘
>>> DaysPerWeek=7
>>> HouersPerDay=24
>>> MinutePerHour=60
>>> MinutePerWeek=DaysPerWeek*HouersPerDay*MinutePerHour
>>> print(MinutePerWeek)
10080
5.如下
x=10
y=20
交换x,y的值
cat 06test.py
x=1
y=2
x,y=y,x
print(x,y)
tmp=x
x=y
y=tmp
print(x,y)
六 Python的运算符
6.1 运算符：
赋值运算符
算术运算符
关系运算符
逻辑运算符
表达式是将不同数据(包括变量,函数)用运算符号按一定规则连接起来的一种式子
算术运算符
优先级:
() > ** > * / // % > ±
>>> 3.0/2 #除法运算
1.5
>>> 3.0//2 #整数除法只取整数
1.0
练习：
古代一斤16两，输入两位数, 返回古代的斤两
vi 09weight.py
num = int (input("请输入两位数:"))
jin = num // 16
liang = num % 16
print ("古代为:" + str(jin) + "斤" + str(liang) + "两")
赋值运算符
>>> a=100 #a赋值为100
>>> a-50 #运算
50
>>> a #a的值不变
100
>>> b=a-50 #给b进行赋值
>>> b
50
>>> a
100
>>> a=a-50 #改变a的值
>>> a
50
= 等于 += 加等于 -= 减等于
*= 乘等于 /= 除等于 %= 模等于 **= 幂方等
比较运算符
逻辑运算符
身份运算符
id() 函数用于返回获取对象的内存地址
>>> x = 100
>>> y = 100
>>> x == y
True
>>> x is y
True
>>> id(x) == id(y)
True
is用于判断两个变量引用的对象是否是同一个, ==用于判断引用变量的值是否相等
位运算符
成员运算符
运算符的优先级
算术运算符 > 比较运算符 > 赋值运算符 > 身份运算符 > 逻辑运算符
相同的优先级一般从做到右进行运算
不需要刻意的记忆 如果担心因为运算符的优先级导致的错误 可以加()进行人为控制
6.2 类型转换
转int 类型：
int (数据)
>>> int ("33")
>>> int (3.14)
>>> int (True)
转float类型：
>>> float(数据)
>>> float(3.14)
3.14
转bool类型：
bool(数据)
>>> bool(None) #None为空数据,返回false
False
>>> bool(1)
True
>>> bool('')
False
>>> bool(' ')
True
转str类型：
str("数据")
>>> str (123)
>>> str(3.14)
混合类型自动升级
print (type(3+3.14))
注意：字符串转换为其他类型时，必须是目标类型的表达式
print (int ("10.5")) #报错
练习：在python命令行输入商品的单价, 购买的数量和支付金额，
计算应该找回多少钱。
>>> unit_price = float(input("请输入商品单价:"))
请输入商品单价:4.8
>>> amount = int(input("请输入商品数量:"))
请输入商品数量:12
>>> pay = float(input("一共支付了:"))
一共支付了:100
>>> change = print("应该找零:" + str(pay - amount * unit_price))
应该找零:42.400000000000006
vi 08pay.py
#!/usr/bin/python3
unit_price = float(input("请输入商品单价:"))
amount = int (input("请输入商品数量:"))
pay = float (input("一共支付了:"))
change = print("应该找零:" + str(pay - amount * unit_price))
练习：实现一个加减乘除的计算器, 输入两个数, 将加减乘除的运算结果显示出来
cat 10Calculator.py
#!/usr/bin/python3
num0 = int (input ("请输入第一个数:"))
num1 = int (input ("请输入第二个数:"))
print ("num0 + num1 = " + str(num0 + num1))
print ("num0 - num1 = " + str(num0 - num1))
print ("num0 * num1 = " + str(num0 * num1))
print ("num0 / num1 = " + str(num0 / num1))
七 Python 的流程控制
7.0 语句
python程序是由各种语句组成的
7.1 行
物理行：程序员编写的一行代码
逻辑行： Python解释器需要执行的一个基本逻辑单元
注意： 一个逻辑行最好运行在一个物理行上
vi 11 row.py
#一个逻辑行占一个物理行
a = 100
b = 200
c = a + b
print (c)
#多个逻辑行占用一个物理行，不建议
a = 100; b = 200; c = a + b; print (c)
换行方式：
隐式换行，直接在小括号内直接进行换行
显示换行，在行位加上 \ 进行换行
#显式换行
d = 1 + \
2 + \
3
#隐式换行
e = (1 +
2 +
3 )
7.3 python的流程控制
if else
if 语句:
Pythond的if语句类似其他语言.if语句包含一个逻辑表达式,使用表达式比较,
在比较的结果的基础上作出决定.
if expression
statement(s)
注:Python使用缩进作为其语句分组的方法,建议使用四个空格代替缩进
代码不规范，家人两行泪，墙裂建议规范代码格式!!!
语法格式:
if 条件1:
语句块1
elif 条件2:
语句块2
elif 语句块3:
语句块3
else 语句块4
语句块4
注意：同级缩进要保持一致，否则将会报错
vi 13if.py
if 1 < 2:
print (True)
print ("Yes") #解释时将直接报错
#如果代码写成下面这样，Yes的缩进如果和if一致，则不受条件影响，
条件不成立时依旧会打印Yes
if 1 > 2:
print (True)
print ("Yes")
elif 可以有0个或多个，但是必须放在if语句的后面
else 可以有0个或者1个，但是必须放在if语句的后面
if 1 < 2:
print (True)
elif 3 > 4:
print ("Yes")
else :
print ("No")
练习：中国传统计时单位。把一昼夜平分为十二段，每段叫做一个时辰，
合现在的两小时。十二个时辰分别以地支为名称，从半夜起算，
半夜十一点到一点是子时依次类推，输入24小时制的时间，输出古代的时辰
vi 14clock.py
clock = int(input("请输入小时:"))
if (clock == 0 or clock == 1):
print ("子时")
elif (clock == 2 or clock == 3):
print ("丑时")
elif (clock == 4 or clock == 5):
print ("寅时")
elif (clock == 6 or clock == 7):
print ("卯时")
elif (clock == 8 or clock == 9):
print ("辰时")
elif (clock == 10 or clock == 11):
print ("巳时")
elif (clock == 12 or clock == 13):
print ("午时")
elif (clock == 14 or clock == 15):
print ("未时")
elif (clock == 16 or clock == 17):
print ("申时")
elif (clock == 18 or clock == 19):
print ("酉时")
elif (clock == 20 or clock == 21):
print ("戌时")
elif (clock == 22 or clock == 23):
print ("亥时")
else :
print ("您输入的有误, 请输入0~23之间的整数")
7.4 真值表达式
非空量 非0=True
空量 0=False
cat 15expression.py
#!/usr/bin/python
def func(): #没关系 就是定义个函数的意思，后面会说
return 1
if func():
print ("ok")
vi 16expression.py
if 100:
print (True)
#等价于
if bool(100):
print (True)
7.5 条件表达式
语法格式：
变量 = 结果1 if 条件 else 结果2
cat 17cond.py
value = 1 if input ("请输入您的性别:") == "男" else 0
练习：输入一个年份，判断闰年还是平年
vi 18leep_year.py
year = int(input ("请输入您想判断的年份:"))
print ("闰年") if (year % 4 == 0 and year % 100 != 0) \
or (year % 400 == 0) else print ("平年")
条件嵌套:
vi 19rain.py
var1 = int(input("下雨吗?[1为下雨;0为未下雨]: "))
if var1 == 1:
var2 = int(input("有伞吗?[1为有;0为没有]: "))
if var2 == 1:
print("出门")
else:
print("家里呆着吧!!!")
else:
print("出门")
练习：
1) 编写一个用来判断成绩优良的python脚本 2科成绩
语文 和 数学 都是 90分以上优秀
语文 和 数学 都是 80分以上良好
语文 和 数学 都是 70分以上中等
语文 和 数学 都是 60分以上及格
语文 和 数学 都是 60分以下不及格
cat 20score.py
chinese = float (input ("请输入您的语文成绩:"))
maths = float (input ("请输入您的数学成绩:"))
if (chinese >= 90 and maths >= 90):
print ("优秀")
elif (chinese >= 80 and maths >= 80):
print ("良好")
elif (chinese >= 70 and maths >= 70):
print ("中等")
elif (chinese >= 60 and maths >= 60):
print ("及格")
elif (chinese < 60 and maths < 60):
print ("不及格,请重修哦")
2) 编写一个用来实现接收用户输入后提示用户登录信息、
判断登录成功与否并密码为隐性的python程序
vi 21getpass.py
import getpass
passwd = getpass.getpass("请输入密码:")
print ("ok") if (passwd == "xxx") else print ("error")
#xxx 是您自己的密码哦, 在Linux中密码都是非明文存储的!!!
八 python中的循环
8.0 循环
循环是一个结构,导致一个程序要重复一定次数.
条件循环也是如此.当条件变为假,循环结束.
8.1 for循环:
在python for循环遍历序列,如一个列表或一个字符.
作用: 用来遍历可迭代对象的数据元素.可迭代对象是指能依次获取数据元素的对象，例如:
容器类型.
语法格式：
for 变量 in 可迭代对象:
# 语句块1
else:
# 语句块2
vi 22for.py
for i in "hello":
print (i)
for 循环中经常用到 range 函数
语法格式：range (开始点， 结束点，间隔)
作用：用来创建一个生成一系列整数的可迭代对象，也叫整数序列生成器
说明：左闭右开 默认的间隔为1 默认开始点为0
vi 23for.py
for i in [0,1,2,3,4,5]:
print (i)
fruit = ['banana', 'apple', 'mango']
for index in range(len(fruit)):
print ("Current fruit:" + str(fruit[index]))
#Current friut: banana Current friut: apple Current friut: mango
vi 24sum.py
sum = 0
#计算1到100的累加和
for i in range (1,101):
sum += i
print (sum)
8.2 跳转语句
break:
跳出当前循环，循环内的后续代码不再执行
vi 26break.py
str = "andy lau"
for c in str:
if (c == 'l'):
print ("\n")
break
print (c, end = "")
continue:
结束本次循环并进入下一次循环
练习: 求 1~ 100之间所有奇数的和
vi 27continue.py
sum = 0
for i in range (1, 101):
if (i % 2 == 0):
continue
else:
sum += i
print (sum)
8.3 空语句
pass, 空语句， 为了保证程序结构的完整性, 一般做占位语句
>>> if True: pass
练习： 循环的嵌套:
a) 使用* 打印一个矩形
vi 28rect.py
high = int (input ("请输入长方形的高:"))
wide = int (input ("请输入长方形的宽:"))
for i in range(1, high+1):
for j in range(1, wide+1):
print ("*", end = "");
print ()
b) 使用*打印一个直角三角形
c) 使用*打印一个等腰三角形
d）使用*打印一个菱形
high = int (input ("请输入长方形的高:"))
wide = int (input ("请输入长方形的宽:"))
for i in range(1, high+1):
for j in range(1, wide+1):
print ("*", end = " ");
print ()
n = int (input ("请输入直角三角形的行数:"))
for i in range(1, n+1):
for j in range(1, i+1):
print ("*", end = "")
print ()
n = int (input ("请输入等腰三角形的行数:"))
for i in range(n):
for j in range(n - i - 1):
print (" ", end = " ")
for j in range(2 * i + 1):
print ("*", end = " ")
print ()
n = int (input("请输入要打印的菱形的行数:"))
if (n % 2 == 0):
n = int (input("请输入奇数:"))
for i in range (1, n // 2 + 2):
print (" " * (n - i), end = " ")
print ("*" * (2 * i - 1))
for i in range (n // 2, 0, -1):
print (" " * (n - i - 1), end = " ")
print ("*" * (2 * i - 1))
print ()
8.3 while循环
while循环
while循环,直到表达式变为假.表达的是一个逻辑表达式,必须返回一个True或者False
语法格式:
while 条件:
#满足条件执行的语句
else
#不满足条件执行的语句
注:遵循代码块缩近原则
else 子句可以省略, 在循环体内用break语句终止循环时, else子句不执行
例如：
vi 29time.py
import time
while True:
for i in range (10, 0, -1):
print (time.strftime("%Y-%m-%d %H:%M:%S")) #打印10次当前系统时间
time.sleep (1)
if (i == 1):
break
break
补充，python中如何查看一个模块所在的位置
import time
help (time) //即可查看到该模块内的所有的方法
import time
key_val = ""
while key_val != 'q':
print ("hello")
time.sleep(1)
key_val = input ("press 'q' to exit...")
if not key_val:
break
vi 30while_sum.py
sum = 0
i = 1
while i <= 100:
sum = sum + i
i += 1
else:
print ("循环结束")
print ("sum = ", sum)
练习：写出1-100内含有7或者7的倍数
vi 31while_777.py
i = 1
for i in range(1, 101, 1):
if ((i % 7) == 0 or ('7' in str(i))):
print (i)
i = 1
while (i < 101):
if ((i % 7 == 0) or '7' in str(i)):
print (i)
i += 1
练习：产生一个1~100之间的随机数, 让用户猜，并统计猜的次数
cat 32random.py
import random
#返回一个1到100之间的随机数
rd = random.randint(1, 100)
print (rd)
times = 0
while True:
guess = int (input("请输入1~100之间的一个随机数:"))
if (guess == rd):
times += 1
print ("恭喜恭喜恭喜你呀,猜对了!")
break
elif (guess > rd):
times += 1
print ("不好意思, 猜大了")
elif (guess < rd):
times += 1
print ("不好意思, 猜小了")
print ("over, 一共猜了:" + str(times) + "次")
九 Python 中的数据类型
前面我们已经在python命令行中体会过了, python有点像c++
类型基本上都封装成了类类型
>>> i = 100
>>> type (i)
<class 'int'> #可以看出来i是int这个类类型的
9.1 python的数据类型
Python 使用对象模型来存储数据。构造任何类型的值都是一个对象。
尽管 Python 通常当 成一种“面向对象的编程语言”，但你完全能够写出不使用任何类和实例的实用脚本。
不过 Python 的对象语法和架构鼓励我们使用这些特性，下面让我们仔细研究一下 Python 对象。
所有的 Python 对像都拥有三个特性：身份，类型和值。
身份:
每一个对象都有一个唯一的身份标识自己，任何对象的身份可以使用内建函数 id()来得到。
这个值可以被认为是该对象的内存地址。您极少会用到这个值，也不用太关心它究竟是什么。
类型:
对象的类型决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。
您可以用内建函数 type()查看 Python 对象的类型。因为在 Python 中类型也是对象
（还记得我们提到 Python 是面向对象的这句话吗?)，所以 type()返回的是对象而不是简单的 字符串。
值:
对象表示的数据项
9.2 数字类型
提供了标量储存和直接访问.他是不可改变类型,也就是说变更数字的值会产生新的对象,
当然,这个过程无论对程序员还是对用户都是透明的,并不会影响软件的开发方式
python支持多种数字类型:整型,长整型,布尔型,双精度浮点型,十进制浮点型和复数
创建数值对象并赋值
>>> anInt=1
>>> aLong=999999999999999999L
>>> afloat=3.14159
更新数值对象(产生新的数值对象)
>>> anInt += 1
>>> anInt
2
删除数值对象
>>> del anInt
9.3 整形
python有几种整型,布尔类型是常规整型
常规整形 整形 长整形
a) 布尔型
该类型取值范围只有两个值 即Flase和True
b) 常规类型
Python语言的整型相当于C语言中的long型，在32位机器上，
整型的位宽为32位，取值范围为 -2147483648～2147483647；
在64位系统上，整型的位宽通常为64位，取值范围为
-9223372036854775808～9223372036854775807
python也支持八进制或者十六进制来表示整型,如果八进制整型以数字"0"开始,
十六进制整型则以"0x"或"0X"开始
c) 长整型
python的长整型类型,请不要将它和C或其他编译型语言的长整型类型混淆.
其他语言的长整型类型的取值范围是32或者64位,python的长整型类型能表达的数值
仅仅与你的机器支持的虚拟内存大小有关,换句话说python能轻松表达很大的整型.
当你的程序需要使用比标准整型类型更大的整型时,就可以使用长整型了,
在一个长整型值后边加L(或者小l)即可.并且这个长整型可以是十进制,八进制,或者十六进制.
d）浮点型
如: 0.0 12.0 -18.0 3e+7等
e）复数类型
python对复数提供内嵌支持，这是其他大部分软件没有的;
复数举例:3.14j,8.32e-36j
常用函数:
divmod() 除法
float() 浮点数
int() 整型
hex() 16进制
oct() 8进制
bin() 2进制
ord() ascii
chr() asc数字转换字符
pow() 指数
round() 四舍五入
9.4 序列
在python的数据类型中,有这样一种类型它的成员是有序排列的,并且可以
通过索引偏移量访问到它一个或者几个成员,这类类型统称为序列,其包含了字符串,元组和列表
字符串: 元组: 列表:
>>> s1 = "abc" >>> t1 = ('a', 'b', 'c') >>> l1 = ['a', 'b', 'c']
>>> s1 >>> t1 >>> l1
'abc' ('a', 'b', 'c') ['a', 'b', 'c']
>>> type (s1) >>> type (t1) >>> type (l1)
<class 'str'> <class 'tuple'> <class 'list'>
字符串：
>>> s2 = "hello andy"
>>> "hello" in s2
True
元组：
>>> t2 = ("hello andy")
>>> "andy" in t2
True
列表:
>>> l2 = ["hello", "andy"]
>>> "andy" in l2
True
序列类型的操作符:
a) 成员关系符(in,not in)
成员关系符号是用来判断一个元素是否属于一个序列的
比如:
对字符串类型来说就是判断一个字符是否属于这个字符串
对元组和列表来说就是判断一个对象是否属于该对象序列
in和not in返回True和False
语法: 对象 [not] in 序列
b) 连接操作符(+)
这个操作符允许我们把一个序列和另一个相同类型的序列做连接
语法:sequence1+sequence2
>>> t2 = ("hello andy")
>>> t3 = (" happy every day!")
>>> t2 += t3
>>> t2
'hello andy happy every day!'
>>> t3
' happy every day!'
>>> t4 = t2 + t3
>>> t4
'hello andy happy every day! happy every day!'
c) 重复语句(*)
当你需要一个序列的多份拷贝时,重复操作符非常有用
语法:sequence * int类型
>>> s1 = "abc"
>>> s1 *= 3
>>> s1
'abcabcabc'
d) 访问序列成员
在python中需要访问单个成员时,可以使用 序列名[索引] 的方式.
索引的范围是从0开始到序列长度-1结束,
语法:sequece[index]
正向索引从0开始，最后一个索引值为len(s) -1
反向索引从-1开始, 最后一个索引值为 -len(s)
vi 33index.py
#!/usr/bin/python3
msg = "hello andy lau!"
print (msg[0]) #h
print (msg[-1]) #!
print (msg[-2]) #u
print (msg[-(len(msg)) + 1]) #e
e) 切片操作([:],[::]) slice
所谓序列类型就是包含一些顺序排列的对象的一个结构,
你可以简单的用方括号加一个索引的方式访问它的每一个元素,
或者通过在方括号中用冒号把开始开始索引和结束索引分开的方式访问一组连续的元素.
语法: sequence[开始索引:结束索引] 注结束索引不包含在内， 左闭右开
语法: 序列容器[开始索引: 结束索引: 步长]
步长是切片每次获取完当前元素后移动的偏移量
开始、结束和步长都可以省略
vi 34slice.py
msg = "hello andy!"
print (msg[0:5:2]) #hlo
print (msg[0:10:1]) #hello andy
print (msg[2:-4]) #llo a
print (msg[:]) #hello andy!
常用函数:
len ()
max ()
min ()
reversed ()
sorted() seq排序
sum() seq求和
str()
list()
tuple()
9.4.1 字符串类型
字符串string
help ('string')
使用引号定义的一组可以包含数字, 字母，符号(非特殊系统符号的集合)
>>> str1 = 'this is a string'
>>> str1 = "this is a string"
>>> str1 = '''this is a string'''
>>> str1 = """this is a string"""
在python中双引号" 和单引号' 相同
注意：引号混用的场景:
>>> str2 = 'let's go'
Cell In[165], line 1
str2 = 'let's go'
^
SyntaxError: unterminated string literal (detected at line 1)
>>> str2 = "let's go"
字符编码：
ASCII编码: 包含英文、数字等字符，每个字符一个字节
GBK编码: 兼容ASCII编码, 包含21003个中文；英文一个字节，汉字两个字节
Unicode编码: 国际统一编码, 旧字符集每个字符2个字节，新字符集4个字节
UTF-8 编码: Unicode的存储与传输方式, 英文1个字节，中文三个字节
python内置函数可以实现字符和unicode 码的相互转换
ord (字符)返回该字符串的Unicode码
chr (整数) 返回该整数对应的字符
练习：循环打印每个文字的编码值， 直到输入'q'
cat 36unicode.py
while True:
str = input ("请输入一个字符:")
if str == 'q':
break
for c in str:
print (f'(c) 对应的unicode编码值为:', ord(c))
转义字符：
f-string 是python3.6之后的版本添加的，称为字面量格式化字符串, 是新的格式化字符串的语法
f-string 格式化字符串以 f开头，后面跟着字符串，字符串中的表达式用大括号{} 包起来，
他会将变量或者表达式计算后的值替换进去
vi 37f_string.py
name = "andy"
age = "19"
print (f'我叫{name} 今年{age} 岁')
字符串的切片:
>>> str1 = "abcdefghijk"
>>> str1 [1:4]
'bcd'
>>> str1 [1:4:2]
'bd'
>>> str1 [-1]
'k'
>>> str1 [-4:-1]
'hij'
>>> str1 [-4:-1:2] #开发中不建议使用负数索引
'hj'
>>> str1 [-1:-4:-1] #开发中不建议使用负数索引
'kji'
字符串的方法：
str.capitalize() #该方法返回一个首字母大写的字符串
str.center(width[, fillchar]) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。
默认填充字符为空格
str.count(sub, start= 0,end=len(string)) #方法用于统计字符串里某个字符出现的次数。
可选参数为在字符串搜索的开始与结束位置
>>> str1 = "hello"
>>> str1.capitalize()
'Hello'
>>> str1.center(20," ")
' hello '
>>> str1.count("l",2,22)
2
str.encode(encoding='UTF-8',errors='strict')
指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案
str.decode(encoding='UTF-8',errors='strict')
指定的编码格式解码字符串。默认编码为字符串编码
str.endswith(suffix[, start[, end]])
方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，
否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
suffix -- 该参数可以是一个字符串也可以是一个元素
start -- 字符串中的开始位置
end -- 字符串中结束的位置
>>> str = "this is a string example!"
>>> str.endswith(suffix, 2, 20)
False
>>> str.endswith(suffix, 2, 25)
True
str.expandtabs(tabsize=8) 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是8
>>> str2 = "this\t is\t a example"
>>> str2.expandtabs(tabsize=4)
'this is a example'
str.find(str, beg=0, end=len(string)) 方法检测字符串中是否包含子字符串 str ，
如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，
如果包含子字符串返回开始的索引值，否则返回-1
str -- 指定检索的字符串
beg -- 开始索引，默认为0
end -- 结束索引，默认为字符串的长度
>>> str2 = "hello andy, happy every day"
>>> str2.find ("andy", 0, len(str2) - 1)
6
str.index(str, beg=0, end=len(string)) 方法检测字符串中是否包含子字符串 str ,
如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，
该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
str -- 指定检索的字符串
beg -- 开始索引，默认为0
end -- 结束索引，默认为字符串的长度
vi 35index.py
str1 = "hello andy, happy ervery day!"
str2 = "andy"
print (str1.index(str2)) #6
print (str1.index(str2, 6, 20)) #6
str.isalnum() 方法检测字符串是否由字母和数字组成
如果字符串由字母和数字组成，则返回True，否则返回False
str.isalpha() 方法检测字符串是否只由字母组成
str.isdigit() 方法检测字符串是否只由数字组成
str.islower()方法检测字符串是否由小写字母组成
str.isnumeric() 方法检测字符串是否只由数字组成，这种方法是只针对unicode对象
str.isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象
str.isspace()方法检测字符串是否只由空格组成
str.title();方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
str.istitle()方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
str.upper()方法将字符串中的小写字母转为大写字母
str.isupper() 方法检测字符串中所有的字母是否都为大写
str.join(sequence) 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
len( str ) 方法返回字符串长度
str.ljust(width[, fillchar]) 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。
如果指定的长度小于原字符串的长度则返回原字符串
str.rjust(width[, fillchar])返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串，
如果指定的长度小于字符串的长度则返回原字符串。
• width -- 指定填充指定字符后中字符串的总长度.
• fillchar -- 填充的字符，默认为空格。
str.lower()方法转换字符串中所有大写字符为小写
str.swapcase();方法用于对字符串的大小写字母进行转换
str.lstrip([chars]) 方法用于截掉字符串左边的空格或指定字符
str.rstrip([chars])删除 string 字符串末尾的指定字符（默认为空格）.
• chars -- 指定删除的字符（默认为空格）
str.strip([chars]);方法用于移除字符串头尾指定的字符（默认为空格）。
• chars -- 移除字符串头尾指定的字符
str.maketrans(intab, outtab) 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
• intab -- 字符串中要替代的字符组成的字符串
• outtab -- 相应的映射字符的字符串
max(str)方法返回字符串中最大的字母
min(str) 方法返回字符串中最小的字母
str.translate(table[, deletechars]); 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符,
要过滤掉的字符放到 del 参数中。
• table -- 翻译表，翻译表是通过maketrans方法转换而来。
• deletechars -- 字符串中要过滤的字符列表。
str.partition(str)方法用来根据指定的分隔符将字符串进行分割.如果字符串包含指定的分隔符，
则返回一个3元的元组，
第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找
str.replace(old, new[, max])方法把字符串中的 old（旧字符串）
替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次
str.rfind(str, beg=0 end=len(string))返回字符串最后一次出现的位置，
如果没有匹配项则返回-1
str.rfind(str, beg=0 end=len(string))返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
str -- 查找的字符串
beg -- 开始查找的位置，默认为0
end -- 结束查找位置，默认为字符串的长度
str.rindex(str, beg=0 end=len(string))返回子字符串 str 在字符串中最后出现的位置，
如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度
str.zfill(width)方法返回指定长度的字符串，原字符串右对齐，前面填充0
str.split(str="", num=string.count(str)).通过指定分隔符对字符串进行切片，如果参数num 有指定值，
则仅分隔 num 个子字符串
• str -- 分隔符，默认为空格。
• num -- 分割次数。
str.splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
• keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，
不包含换行符，如果为 True，则保留换行符。
str.startswith(str, beg=0,end=len(string));方法用于检查字符串是否是以指定子字符串开头，
如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
• str -- 检测的字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置。
• strend -- 可选参数用于设置字符串检测的结束位置
str3 = "andy2024"
str4 = "balabala_2035"
print (str3.isalnum()) #True
print (str4.isalnum()) #False
str5 = "balabala"
print (str5.isalpha()) #True
print (str5.isdigit()) #False
print (str5.islower()) #True
str6 = u"123456"
print (str6.isnumeric()) #True
print (str6.isdecimal()) #True
str1 = " "
print (str1.isspace())
str1 = "Hello andy"
print (str1.istitle())
print (str1.title()) #Hello Andy
str1 = "HELLO"
print (str1.isupper())
str1 = "-"
str2 = ("a", "b", "c")
str1.join (str2)
print (len(str1)) #1
print (str1.ljust(10, "\\")) #-\\\\\\\\\
print (str1.rjust(10, "\\")) #\\\\\\\\\-
str1 = "Andy"
print (str1.lower()) #andy
print (str1.swapcase()) #aNDY
str1 = "***andy***"
print (str1.lstrip("*")) #andy***
print (str1.rstrip("*")) #***andy
print (str1.lstrip("*").rstrip("*")) #andy
print (str1.strip("*")) #andy
intab = "1234"
outtab = "siad"
str1 = "Th21 21 3n4y"
transtab = str1.maketrans(intab, outtab)
print (str1.translate(transtab)) #This is andy
print (max(str1)) #y
print (min(str1)) #
str1 = "https://www.baidu.com"
print (str1.partition("://")) #('https', '://', 'www.baidu.com')
print (str1.rpartition("://")) #('https', '://', 'www.baidu.com')
str1 = "hello andy, andy lau"
print (str1.replace("andy", "德华")) #hello 德华, 德华 lau
print (str1.rfind("andy")) #12
print (str1.rindex("andy")) #12
print (str1.zfill(20))
print (str1.split(","))
str1 = "hello\r andy\n, andy\r\n lau\n"
print (str1.splitlines(False)) #['hello', ' andy', ', andy', ' lau']
print (str1.startswith ("hello", 0 , 5)) #True
练习：
在终端中循环输入字符串，如果输入exit则退出，否则以"_"拼接所有输入的内容
content = []
while True:
str = input ("请输入字符串:")
if str != 'exit':
content.append(str)
else:
break
str1 = '-'.join(content)
print (f'用户输入:{str1}')
9.4.2 元组类型
元组
元组和列表十分类似,只不过元组和字符串一样是不可变得，即不能修改元组的值
>>> a = '123'
>>> id(a)
140291637197424
>>> a = 'abc'
>>> id(a)
8481664
上例说明变量a定义的两个变量是存放到不同的内存地址空间的,即不可变.
比如c语言你要定义一个类型的时候要先开辟一段内存地址空间,
比如说该空间定义的是整型,那么你后期重新赋值时也一定是整型.
而python是现在内存中存储数据之后在通过一个标签去引用它,
值的类型是在内存中已经存好了,不需要事先定义这段空间存什么值,
所以说不同的字符串会占用不同的存储空间,所以我们无法改变
元组通过圆括号中用逗号分割的项目定义.
元组通常用在使语句或用户定义的函数能够安全的采用一组值的时候被使用,元组的值不会改变
>>> userinfo1 = "andy is happy today"
>>> userinfo1[:5]
'andy '
>>> userinfo1 = "andy's singing is beautiful"
>>> userinfo1[:5]
"andy'"
元组的使用:
>>> arr = ("andy", "19", "male")
>>> arr[0]
'andy'
>>> arr[1]
'19'
>>> arr[2]
'male'
>>> arr1 = () #空元组
>>> type(arr1)
<class 'tuple'>
>>> arr2 = (2, ) #一个元素的元组必须写,
>>> type (arr2)
<class 'tuple'>
元组操作
元组和字符串类型一致也属于序列类型, 可以通过索引和切片进行操作
>>> arr = ("andy", "19", "male")
>>> arr
('andy', '19', 'male')
>>> arr[1]
'19'
>>> arr[1] = 30
Traceback (most recent call last):
Cell In[31], line 1
arr[1] = 30
TypeError: 'tuple' object does not support item assignment
# 可以看得出来, 元组是不支持赋值操作的
赋值给变量(元组拆分)
>>> arr = ("andy", "19", "male")
>>> name, age, gender = arr
>>> name
'andy'
>>> age
'19'
>>> gender
'male'
元组中如果含有列表可以改变
cat 38tuple.py
t1 = ('a', '1', ['b', 'c'])
print (id(t1)) #124635309478464
print (t1[0]) #'a'
print (t1[1]) #'1'
print (t1[2]) #['b', 'c']
print (t1[2][0]) #'b'
print (t1[2][1]) #'c'
t1[2][0] = 'e'
t1[2][1] = 'f'
print (t1[2][0]) #'e'
print (t1[2][1]) #'f'
print (id(t1)) #124635309478464
元组的方法： index 和count
>>> t2 = ('hello', "andy")
>>> help(t2.index)
>>> help (t2.count)
>>> print (t2.count("hello")) #1
>>> print (t2.index("hello")) #0
注:以上元组名称为 对象 index和count为方法 可以理解为bash中的函数
9.4.3 列表类型
list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目.
列表是可变类型的数据
列表的组成:用[]表示列表,包含了多个以逗号分隔开的数字,或者字符串
cat 39list.py
list1 = ['andy', 'lau']
list2 = [1,2,3,4,5]
list3 = ["str1", 2,3,4]
print (type (list1)) #<class 'list'>
列表与元组相比较， 切片是没有区别的， 但是元组中只有一个元素时，该元组是一个字符串，
而列表中如果只有一个元素也是列表
list = ['andy', '19', 'male']
arr = ('andy', '19', 'male')
print (list[0:2]) #['andy' '19']
print (arr[0:2]) #('andy' '19')
arr1 = ("andy")
print (type(arr1)) #<class 'str'>
list1 = ["andy"]
print (type(list1)) #<class 'list'>
列表的相关操作：
取值，索引以及切片
扫一扫
364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
