一种面向对象,面向函数的解释型计算机程序设计语言,函数式编程(函数可以作为参数传递)
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
用途:机器学习,爬虫,服务器脚本,web,网络协议
解释器:Cpython,JPython,PyPython
版本:2.7.15,3.6.4
优缺点:简单,易学,免费开源,高层语言(不需要考虑程序所使用的内存大小),可移植性,面向对象,可扩展性,拥有丰富的库NumPy 用于科学计算机器学习,规范代码(强制缩进)
应用场景:web应用开发Django,操作系统管理、服务器运维的自动化脚本,科学计算机器学习NumPy,服务器软件(网络软件)阿里云
安装python3环境
Anaconda3-5.2.0-Windows-x86_64.exe
在这个页面全勾选
此时可在cmd中执行python命令。
安装python2环境
python-2.7.15.amd64.msi
PythonIDE的安装:
(1)eclipse插件安装
Help—> eclipse marketplace—> pydev(较慢)
插件包:加压拷贝到eclipse的dropins中,重启即可
(2)pycharm安装
傻瓜式安装,创建新的项目的时候直接选择sdk
在cmd窗口中支持交互式窗口: ipython
安装:pip install ipython 执行:ipython
支持变量自动补全,自动缩进,支持 bash shell 命令,内置了许多很有用的功能和函数
注意:Python中本身不带有这个ipython的交互,需要自行安装。首先查看计算机中是否包含pip,一般安装完之后可能会有错,执行python –m pip install –upgrade pip,先将pip进行更新,然后安装ipython:pip install ipython
1、下载python
1) 下载地址:https://www.python.org/downloads/release/python-364/
2) 解压到F:\Python36
3) 将F:\Python36,F:\Python36\Scripts添加到PATH环境变量中
4) 更改pip的源
在C:\Users\\创建pip目录,其中添加pip.ini
在pip.ini中添加如下语句:
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=mirrors.aliyun.com
5) 打开cmd,输入pip install ipython进行安装
6) 打开cmd,输入python -m pip install --upgrade pip升级pip
2、下载和安装Anaconda
Anaconda各个版本的下载地址:
https://repo.anaconda.com/archive/
3、下载和使用PyDev
PyDev 6.4.4.zip下载地址:
https://excellmedia.dl.sourceforge.net/project/pydev/pydev/PyDev%206.4.4/PyDev%206.4.4.zip
Need to use older Eclipse/Java/Python
If you need to use an older version of Eclipse/Java/Python, below is the latest PyDev version to be used based on your requisites.
• Eclipse 4.5, Java 8: PyDev 5.2.0
• Eclipse 3.8, Java 7: PyDev 4.5.5
• Eclipse 3.x, Java 6: PyDev 2.8.2
• Python 2.5 or older: PyDev 5.5.0
将下载的zip包解压后放到eclipse的dropin目录中重启eclipse即可。
在pycharm中禁止使用test开头的py文件,默认是单元测试。Eclipse中随意
input和raw_input的区别在于:input会将输入的字符串看作是变量名称,而raw_input不会
input和raw_input的区别在python2中出现,python3中没有这个问题了。
在环境变量配置:
Anaconda3的Library\bin
Anaconda3的根目录
Anaconda3的Scripts
其他的python2和python3从环境变量删除
Python2.x
1、 下载Python2.x的包
2、 tar –zxvf python-2.7.15.tar
3、 yum install gcc
4、 ./configure
5、 Make && make install
Python3.x
1、 依赖环境:yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel
2、 下载Python3的包
3、 tar –zxvf python-3.6.1.tgz
4、 ./configure
5、 Make && make install
6、 添加环境变量
单行注释:以#开头,#右边的所有东西当做说明,而不是真正要执行的程序,起辅助说明作用
多行注释:’’’多行注释’’’可以写多行的功能说明
'''
单行注释使用#
多行注释使用'''
'''
'''
print("hello python")
Python乱码问题
由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:
# -*- coding:utf-8 -*-
# coding=utf-8
注意:idea不要使用test开头来作为文件名,因为test开头会默认为是测试文件,eclipse无所谓
在Python中,存储一个数据,需要一个叫做变量的东西:
例如:num1=100
Num2=87
Result=num1+num2
变量三要素:变量的名称,变量的类型,变量的值
定义在类外的叫函数function,定义在类里面的叫方法method
class Person:
def eat(self):# 方法:定义在类里面的叫方法
print("person.run")
def fun():# 函数:定义在类外的叫函数
print("fun")
fun()
Person.eat()
object 必须小写o
Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1,100,-8080,0,等等。
计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用0x前缀和0-9,a-f表示,例如:0xff00,0xa5b4c3d2,等等。
浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等的。浮点数可以用数学写法,如1.23,3.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。
整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。
字符串是**以单引号'
或双引号"
**括起来的任意文本,比如'abc'
,"xyz"
等等。请注意,’‘或"“本身只是一种表示方式,不是字符串的一部分,因此,字符串’abc’只有a,b,c这3个字符。如果’本身也是一个字符,那就可以用”"括起来,比如"I’m OK"包含的字符是I,’,m,空格,O,K这6个字符。
如果字符串内部既包含’又包含"怎么办?可以用转义字符\来标识,比如:
'I\'m \"OK\"!'
表示的字符串内容是:
I'm "OK"!
转义字符\可以转义很多字符,比如\n表示换行,\t表示制表符,字符\本身也要转义,所以\\表示的字符就是\,可以在Python的交互式命令行用print()打印字符串看看:
如果字符串里面有很多字符都需要转义,就需要加很多\,为了简化,Python还允许用r’‘表示’'内部的字符串默认不转义,可以自己试试:
如果字符串内部有很多换行,用\n写在一行里不好阅读,为了简化,Python允许用’’’…’’'的格式表示多行内容,
print('''hello
world
python
''')
布尔值和布尔代数的表示完全一致,一个布尔值只有True、False两种值,要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(请注意大小写),也可以通过布尔运算计算出来
布尔值可以用and、or和not运算。
and运算是与运算,只有所有都为True,and运算结果才是True:
空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。
此外,Python还提供了列表、字典等多种数据类型,还允许创建自定义数据类型
怎样知道一个变量的类型呢?
在python中,只要定义了一个变量,而且它有数据,那么它的类型就已经确定了,不需要咱们开发者主动的去说明它的类型,系统会自动辨别
可以使用type(变量的名字),来查看变量的类型
a=10
a="abcd"
a=3.14
print(a)
print(type(a))
b='qwer'
print(b)
print(type(b))
str1='i\'m ok'
str2="i'm ok"
print(str1)
print(str2)
print('''hello
world
python
''')
flag=True
flag=False
str=None
a="123"
b=int(a)
print(type(b))
开发人员在程序中自定义的一些符号和名称,标示符是自己定义的,如变量名 、函数名等
思考:下面的标示符哪些是正确的,哪些不正确为什么
fromNo12 from#12 my_Boolean my-Boolean Obj2 2ndObj myInt
test1 Mike2jack My_tExt _test test!32haha(da)ttint jack_rose jack&rose GUI G.U.I
不正确:from#12 2ndObj test!32haha(da)ttint jack&rose G.U.I
注意:pycharm不要使用test开头来作为文件名,因为test开头会默认为是测试文件,eclipse无所谓
命名规则:见名知义、驼峰式命名
python一些具有特殊功能的标示符,这就是所谓的关键字
关键字,是python已经使用的了,所以不允许开发者自己定义和关键字相同的名字的标示符
查看关键字:(保留字)
And as assert break class continue def
del elif else except exec finally for
from global if in import is lambda
not or pass print raise return try
while with yield
可以通过以下命令进行查看当前系统中python的关键字:
import keyword
print(keyword.kwlist)
['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']
简介
and:表示逻辑‘与’
del:用于list列表操作,删除一个或者连续几个元素。
from:导入相应的模块,用import或者from…import
not:表示逻辑‘非’
while:while循环,允许重复执行一块语句,一般无限循环的情况下用它
as:as单独没有意思,是这样使用:with…as用来代替传统的try…finally语法的。
elif:和if配合使用的,if语句中的一个分支用elif表示。
global :定义全局变量
例如:
name = 10
age = 20
def test():
global name
age = 30
name = 'aa'
#print(name)
test()
print(name) # 'aa'
print(age) # 20
or:表示逻辑“或”
with:和as一起用,使用的方法请看as,见with
assert:表示断言(断言一个条件就是真的,如果断言出错则抛出异常)用于声明某个条件为真,如果该条件不是真的,则抛出异常:AssertionError
v1 = 10
v2 = 20
assert(v1 > v2)
else:参考下面if的解释
if:if语句用于选择分支,依据条件选择执行那个语句块。(if语句中最好不要嵌套if语句,建议把嵌套的if语句写在另一个函数中)
pass:pass的意思就是什么都不做(当方法内不想写东西时可以将pass写入方法)
def fun():
pass
fun()
yield:用起来和return很像,但它返回的是一个生成器
break:作用是终止循环,程序走到break的地方就是循环结束的时候。
except:和try一起使用,用来捕获异常。
import:用来导入模块,有时这样用from…import
class:定义类
in:查找列表中是否包含某个元素,或者字符串a是否包含字符串b。
raise:raise可以显示地引发异常。一旦执行raise语句,后面的代码就不执行了
continue:跳过continue后面循环块中的语句,继续进行下一轮循环。
finally:看到finally语句,必然执行finally语句的代码块。
is:Python中的对象包含三要素:id、type、value,用来判断对象是否相等
return:用于跳出函数,也可以在跳出的同时返回一个值。
def:用于定义方法
for:for…in 一起使用:它在一序列的对象上递归,就是遍历队列中的每个项目
lambda:即匿名函数
try:出现在异常处理中,使用格式为:try…except,try中放想要执行的语句,except捕获异常
nonlocal:nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量
例如:
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
def make_counter_test():
mc = make_counter()
print(mc())
print(mc())
print(mc())
make_counter_test()
用print()在括号中加上字符串,就可以向屏幕上输出指定的文字。
print()函数也可以接受多个字符串,用逗号“,”隔开,就可以连成一串输出:
print("hello","world",678)
print()会依次打印每个字符串,遇到逗号“,”会输出一个空格,因此,输出的字符串是这样拼起来的:
hello world 678
print()也可以打印整数,或者计算结果
print(100+200)
因此,我们可以把计算100 + 200的结果打印得更漂亮一点:
print('100 + 200 =', 100 + 200)
%运算符就是用来格式化字符串的。在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个%?占位符,后面就跟几个变量或者值,顺序要对应好。如果只有一个%?,括号可以省略。
print("%d+%d=%d"%(100,200,300))
abc="hello"
print("%s,world"%"hello")
print("%s,world"%abc)
100+200=300
hello,world
hello,world
常见的占位符有:
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
其中,格式化整数和浮点数还可以指定是否补0和整数与小数的位数:
f=123.456
print("%.1f"%f)
print("%.2f"%f)
print("%2d-%02d"%(3,1))
结果
123.5
123.46
3-01
如果你不太确定应该用什么,%s永远起作用,它会把任何数据类型转换为字符串
有些时候,字符串里面的%是一个普通字符怎么办?这个时候就需要转义,用%%来表示一个%:
print("growth rate:%d%%"%7)
growth rate:7%
Python提供了一个input(),可以让用户输入字符串,并存放到一个变量里
1.python2版本中
raw_input()
在Python中,获取键盘输入的数据的方法是采用 raw_input 函数。
看如下示例:
注意:
raw_input()的小括号中放入的是,提示信息,用来在获取数据之前给用户的一个简单提示
raw_input()在从键盘获取了数据以后,会存放到等号右边的变量中
raw_input()会把用户输入的任何值都作为字符串来对待
input()
input()函数与raw_input()类似,但其接受的输入作为是表达式。
input()接受表达式输入,并把表达式的结果赋值给等号左边的变量
raw_input()输入的都当成字符串(和Python3的input功能一样)
注意:py2版本的input()只能跟表达式,如果要跟字符串必须加双引号引起来
>>> s=input("请输入字符串:")
请输入字符串:abc
Traceback (most recent call last):
File "" , line 1, in <module>
File "" , line 1, in <module>
NameError: name 'abc' is not defined
>>> s=input("请输入字符串:")
请输入字符串:123
>>> print(s)
123
>>> s=input("请输入字符串:")
请输入字符串:"abc"
>>> print(s)
abc
>>> s=raw_input("请输入")
请输入abc
>>> print(s)
abc
>>> abc="cw"
>>> a=input("请输入:")
请输入:abc
>>> print(a)
cw
2.python3版本中
没有raw_input()函数,只有input()
并且 python3中的input与python2中的raw_input()功能一样
input()接收的数据均为String类型
s=input("请输入数字:")
print(s)
s=input("请输入字符串:")
print(s)
结果
请输入数字:18
18
请输入字符串:abc
abc
下面以a=10 ,b=20为例进行计算
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 | 两个对象相加 a + b 输出结果 30 |
- | 减 | 得到负数或是一个数减去另一个数 a - b 输出结果 -10 |
* | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200 |
/ | 除 | x除以y b / a 输出结果 2 |
// | 取整除 | 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
% | 取余(取模) | 返回除法的余数 b % a 输出结果 0 |
** | 幂 | 返回x的y次幂 a**b 为10的20次方, 输出结果 100000000000000000000 |
print(10/3)
print(10//3)
print(10//3.0)
print(2**3)
结果
3.3333333333333335
3
3.0
8
运算符 | 描述 | 实例 |
---|---|---|
= | 赋值运算符 | 把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7 |
>>> a, b = 1, 2
>>> a
1
>>> b
2
运算符 | 描述 | 实例 |
---|---|---|
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
%= | 取模赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
注意:Python中没有a++,a–,++a,–a等操作
运算符 | 逻辑表达式 | 描述 | 实例 |
---|---|---|---|
and | x and y | 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 | (a and b) 返回 20。 |
or | x or y | 布尔"或" - 如果 x 是 True,它返回 True,否则它返回 y 的计算值。 | (a or b) 返回 10。 |
not | not x | 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 | not(a and b) 返回 False |
运算符 | 描述 | 示例 |
---|---|---|
== | 检查两个操作数的值是否相等,如果是则条件变为真。 | 如a=3,b=3则(a == b) 为 true. |
!= | 检查两个操作数的值是否相等,如果值不相等,则条件变为真。 | 如a=1,b=3则(a != b) 为 true. |
<> | 检查两个操作数的值是否相等,如果值不相等,则条件变为真。 | 如a=1,b=3则(a <> b) 为 true。这个类似于 != 运算符 |
> | 检查左操作数的值是否大于右操作数的值,如果是,则条件成立。 | 如a=7,b=3则(a > b) 为 true. |
< | 检查左操作数的值是否小于右操作数的值,如果是,则条件成立。 | 如a=7,b=3则(a < b) 为 false. |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是,则条件成立。 | 如a=3,b=3则(a >= b) 为 true. |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是,则条件成立。 | 如a=3,b=3则(a <= b) 为 true. |
计算机之所以能做很多自动化的任务,因为它可以自己做条件判断。
elif是else if的缩写,完全可以有多个elif,所以if语句的完整形式就是:
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
age = input("请输入年龄:")
age = int(age)
if (age < 20):
print("小孩")
elif (age < 40):
print("青年")
else:
print("老年")
if判断条件还可以简写,比如写:
if x:
print('True')
只要x是非零数值、非空字符串、非空list等,就判断为True,否则为False。
最后看一个有问题的条件判断。很多同学会用input()读取用户的输入,这样可以自己输入,程序运行得更有意思:
birth = input('birth: ')
if birth < 2000:
print('00前')
else:
print('00后')
输入1982,结果报错:
这是因为input()返回的数据类型是str,str不能直接和整数比较,必须先把str转换成整数。Python提供了int()函数来完成这件事情:
s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00后')
再次运行,就可以得到正确地结果。但是,如果输入abc呢?又会得到一个错误信息:
Traceback (most recent calllast):
File "", line 1, in
ValueError: invalid literal forint() with base 10: 'abc'
原来int()函数发现一个字符串并不是合法的数字时就会报错,程序就退出了。
如何检查并捕获程序运行期的错误呢?后面的错误和调试会讲到。
if 条件1:
满足条件1 做的事情1
满足条件1 做的事情2
...(省略)...
if 条件2:
满足条件2 做的事情1
满足条件2 做的事情2
...(省略)...
说明:
外层的if判断,也可以是if-else
内层的if判断,也可以是if-else
根据实际开发的情况,进行选择
案例
要求:从键盘输入刀子的长度,如果刀子长度没有超过10cm,则允许上火车,否则不允许上火车
length=input("请输入小刀的长度:")
length=int(length)
if(length<=10):
print("允许上车,长度为:%d"%length)
else:
print("不允许上车,长度为:%d,超出范围:10"%length)
小明身高1.75,体重80.5kg。请根据BMI公式(体重除以身高的平方)帮小明计算他的BMI指数,并根据BMI指数:
低于18.5:过轻
18.5-25:正常
25-28:过重
28-32:肥胖
高于32:严重肥胖
用if-elif判断并打印结果:
high=input("请输入身高(m)\n")
weight=input("请输入体重(kg)\n")
high=float(high)
weight=float(weight)
BMI=weight/(high**2)
if(BMI<18.5):
print("BMI:%f,过轻"%BMI)
elif(BMI<25):
print("BMI:%f,正常"%BMI)
elif(BMI<28):
print("BMI:%f,过重"%BMI)
elif(BMI<32):
print("BMI:%f,肥胖"%BMI)
else:
print("BMI:%f,严重肥胖"%BMI)
Python的循环有两种,一种是for…in循环,另外一种是while循环。
while 条件:
条件满足时,做的事情1
条件满足时,做的事情2
条件满足时,做的事情3
...(省略)...
1. 计算1~100的累积和(包含1和100)
# encoding=utf-8
i = 1
sum = 0
while i <= 100:
sum = sum + i
i += 1
print("1~100的累积和为:%d" % sum)
2. 计算1~100之间偶数的累积和(包含1和100)
# encoding=utf-8
i = 1
sum = 0
while i <= 100:
if (i % 2 == 2):
sum = sum + i
i += 1
print("1~100的偶数的累积和为:%d" % sum)
while 条件1:
条件1满足时,做的事情1
条件1满足时,做的事情2
条件1满足时,做的事情3
...(省略)...
while 条件2:
条件2满足时,做的事情1
条件2满足时,做的事情2
条件2满足时,做的事情3
...(省略)...
1.要求:打印如下图形: m行,每行打印n次,n==m
*
* *
* * *
* * * *
* * * * *
i = 1
while (i <= 5):
j = 1
while (j <= i):
print("*", end=' ')
j += 1
print()
i += 1
2. 九九乘法表
i = 1
while (i <= 9):
j = 1
while (j <= i):
print("%d*%d=%d" % (i, j, i * j), end='\t')
j += 1;
print()
i += 1
像while循环一样,for可以完成循环的功能。
在Python中 for循环可以遍历任何序列的项目,如一个列表或者一个字符串等。
for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
else:
循环不满足条件时执行的代码
Range函数
# for i in 1,2,3,4,5,6,7,8,9,10:
# print(i)
# for i in range(1,10):
# print(i)
#输出1,3,5,7,9
# for i in range(1,10,2):
# print(i)
for i in "asf":
print(i)
for i in "asf","dfsdf","sdfsd":
print(i)
else:
print("循环完了")
输出
a
s
f
asf
dfsdf
sdfsd
循环完了
九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%d"%(i,j,i*j),end='\t')
print()
break
在循环中,break语句可以提前退出循环。例如,本来要循环打印1~100的数字:
n = 1
while n <=100:
print(n)
n = n + 1
print('END')
上面的代码可以打印出1~100。
如果要提前结束循环,可以用break语句:
n = 1
while n <= 100:
print(n)
if n > 10: # 当n = 11时,条件满足,执行break语句
break # break语句会结束当前循环print(n)
n = n + 1
print('END')
continue
在循环过程中,也可以通过continue语句,跳过当前的这次循环,直接开始下一次循环。
n = 0
while n < 10:
n = n + 1
if n % 2 == 0: # 如果n是偶数,执行continue语句continue
continue # continue语句会直接继续下一轮循环,后续的print()语句不会执行
print(n)
String字符串:不可变类型
所谓下标,就是编号,就好比超市中的存储柜的编号,通过这个编号就能找到相应的存储空间
字符串实际上就是字符的数组,所以也支持下标索引,可通过下标索引来获取对应位置的值
从左边数下标是从0开始,从右边数是从-1开始。
如果有字符串:name = ‘abcdef’,在内存中的实际存储如下:
如果想取出部分字符,那么可以通过下标的方法,(注意python中从左边数下标是从0开始,从右边数是从-1开始。)
name = 'abcdef'
print(name[0]) # a
print(name[1]) # b
print(name[-2]) # e
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。类似substring
切片的语法:
[起始:结束:步长]
步长:表示下标变化的规律。
注意:选取的区间属于左闭右开型,即从"起始"位开始,到"结束"位的前一位结束(不包含结束位本身)。
我们以字符串为例讲解。
如果取出一部分,则可以在中括号[]中,使用:
注意:如果步长为负数,则代表从右往左列出,起始位置要比介绍位置索引大
如有字符串mystr = ‘hello world and bjsxt yunshuxueyuan sxt beijing’,以下是常见的操作
<1>find == java Indexof方法
检测 str 是否包含在 mystr中,如果是返回开始的索引值,否则返回-1
返回指定子串在str中从左边数第一次出现的位置的下标
mystr.find(str, start=0, end=len(mystr))
<2>index
跟find()方法一样,只不过如果str不在 mystr中会报一个异常.
返回指定子串在str中从左边数第一次出现的位置的下标
mystr.index(str, start=0, end=len(mystr))
<3>count
返回 str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))
<4>replace
把 mystr 中的 str1 替换成 str2,如果 count 指定,则替换不超过 count 次.
mystr.replace(str1, str2, mystr.count(str1))
<5>split
以 str 为分隔符切片 mystr,如果 maxsplit有指定值,则仅分隔 maxsplit 个子字符串
mystr.split(str=" ", 2)
<6>capitalize
把字符串的第一个字符大写
mystr.capitalize()
<7>title
把字符串的每个单词首字母大写
<8>startswith
检查字符串是否是以 obj 开头, 是则返回 True,否则返回 False
mystr.startswith(obj)
<9>endswith
检查字符串是否以obj结束,如果是返回True,否则返回 False.
mystr.endswith(obj)
<10>lower
转换 mystr 中所有大写字符为小写
mystr.lower()
<11>upper
转换 mystr 中的小写字母为大写
mystr.upper()
<12>ljust
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
mystr.ljust(width)
mystr.ljust(width,字符):可以自定义字符设置为填充字符如mystr.ljust(width,’*’)
<13>rjust
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
mystr.rjust(width)
<14>center
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
mystr.center(width)
print(mystr.center(100,’*’))
mystr = 'hello world'
print(mystr.ljust(30,'*'))
print(mystr.rjust(30,'*'))
print(mystr.center(30,'*'))
print("*"*30)
结果
hello world*******************
*******************hello world
*********hello world**********
******************************
<15>lstrip
删除 mystr 左边的空白字符
mystr.lstrip()
<16>rstrip
删除 mystr 字符串末尾的空白字符
mystr.rstrip()
<17>strip —java trim
删除mystr字符串两端的空白字符
<18>rfind
类似于 find()函数,不过是从右边开始查找.返回指定子串在str中从右边数第一次出现的位置的下标
mystr.rfind(str, start=0,end=len(mystr) )
<19>rindex 返回指定子串在str中从右边数第一次出现的位置的下标
类似于 index(),不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr))
<20>partition
把mystr以str分割成三部分,str前,str和str后
mystr.partition(str)
<21>rpartition
类似于 partition()函数,不过是从右边开始.
mystr.rpartition(str)
<22>splitlines
按照换行符分隔,返回一个包含各行作为元素的列表
mystr.splitlines()
<23>isalpha
如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isalpha()
<24>isdigit
如果 mystr 只包含数字则返回 True 否则返回 False.
mystr.isdigit()
<25>isalnum
如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isalnum()
<26>isspace
如果 mystr 中只包含空格,则返回 True,否则返回 False.
mystr.isspace()
<27>join
mystr 中每个字符后面插入list的每个元素后面,构造出一个新的字符串
mystr.join(list)
mystr = 'hello world'
print(mystr.join(['first ',' second ',' third']))# 将mystr添加到每个集合成员之间
print(mystr.join(['first ',' second ',' third ',' forth']))
first hello world second hello world third
first hello world second hello world third hello world forth
注意:
查找字符串:
str.index(“指定子串”) :返回指定子串在str中从左边数第一次出现的位置的下标
str.rindex(“指定子串”) :返回指定子串在str中从右边数第一次出现的位置的下标
以上两方法如果找不到指定子串会报错。
str.find(“指定子串”) :返回指定子串在str中从左边数第一次出现的位置的下标
str.rfind(“指定子串”) :返回指定子串在str中从右边数第一次出现的位置的下标
以上两方法如果找不到指定子串时就会返回-1
Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素。
列表用[ ]标识,用len()函数可以获取list元素个数,可以用下标索引来获取指定位置的元素。
列表中的数据是可以进行修改的。
比如,列出班里所有同学的名字,就可以用一个list表示:
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
变量classmates就是一个list。用len()函数可以获得list元素的个数:
>>> len(classmates)
3
用索引来访问list中每一个位置的元素,记得索引是从0开始的:
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
File "" , line 1, in <module>
IndexError: list index out of range
当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates) - 1。
如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:
>>> classmates[-1]
'Tracy'
列表中存放的数据是可以进行修改的,比如"增"、“删”、“改”"
1.添加元素("增"append, extend, insert)
a.append(b) :将b完整追加到a中
a.extend(b):将表中元素一个一个取出来加到a中
a.insert(index,object): 在指定位置index前插入元素object
list = ["hello", 123, True, 345.678]
list2 = ["q", "w", "e"]
list3 = ["q", ["w", "e"]]
list.append("qwer")
print(list)
list.insert(2, "qqq")
print(list)
list.extend(list2)
print(list)
list.extend(list3)
print(list)
['hello', 123, True, 345.678, 'qwer']
['hello', 123, 'qqq', True, 345.678, 'qwer']
['hello', 123, 'qqq', True, 345.678, 'qwer', 'q', 'w', 'e']
['hello', 123, 'qqq', True, 345.678, 'qwer', 'q', 'w', 'e', 'q', ['w', 'e']]
2.修改
修改元素的时候,要通过下标来确定要修改的是哪个元素,然后才能进行修改
list = ["hello", 123, True, 345.678]
list[0]="world"
print(list)
显示为:
['world', 123, True, 345.678]
3.查找
所谓的查找,就是看看指定的元素是否存在
in(存在),如果存在那么结果为true,否则为false
not in(不存在),如果不存在那么结果为true,否则false
index, count index和count与字符串中的用法相同
findName="李四"
nameList=["张三","李四","王五"]
#查找是否存在
if findName in nameList:
print('在字典中找到了相同的名字')
else:
print('没有找到')
a = ['a', 'b', 'c', 'a', 'b']
print(a.index('a', 0, 3)) # 注意是左闭右开区间
print(a.index('a', 0, -1)) # 注意是左闭右开区间
print(a.count('a'))
在字典中找到了相同的名字
0
0
2
4删除:
del:根据下标进行删除,其实可以删除所有变量
pop:默认删除最后一个元素
remove:根据元素的值进行删除第一个
a = ['a', 'b', 'c', 'a', 'b','b','a']
a.remove("c")
print(a)
a.pop()
print(a)
a.pop(2)
print(a)
del a[0]
print(a)
print(len(a))
del a # 删除全部
5.排序:
sort方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。
reverse方法是将list逆置。
a = ['a', 'b', 'c', 'a', 'b','b','a']
a.sort()
print(a)
b=[2,1,4,3,6,5,8,7,10,9]
b.sort()
print(b)
b.sort(reverse=True)
print(b)
b.reverse()
print(b)
c=["aac","aaa","aab","abc","aba"]
c.sort()
print(c)
d=[False,True,True,False]
d.sort()
print(d)
---------结果
['a', 'a', 'a', 'b', 'b', 'b', 'c']
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
['aaa', 'aab', 'aac', 'aba', 'abc']
[False, False, True, True]
6.按键值对形式输出列表中元素的下标和值: enumerate()
nameList = ["Mike","Jack","Sarah"]
for i,name in enumerate(nameList):
print(i,name)
0 Mike
1 Jack
2 Sarah
Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。
元组的元素不可修改,用()用作标识。
元素不可变指的是元素的指向不可变,当某个位置的元素指向一个list列表时,不可再指向其他列表,但是这个列表内的元素是可以被改变的。
可以用下标来访问元组中元素
tuple=(1,"abcd",True,1.123)
print(tuple)
print(tuple[2])
# 如果要定义一个空的tuple,可以写成():
t=()
# 定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。
t=(1)
# 所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义:
t=(1,)
# Python在显示只有1个元素的tuple时,也会加一个逗号,,以免你误解成数学计算意义上的括号。
python不允许修改元组的数据,包括不能删除其中的元素
t=(123,456,789)
t[1]=188
print(t)
Traceback (most recent call last):
File "D:/PycharmProjects/PythonTest/com/cw/python/01HelloWorld.py", line 2, in <module>
t[1]=188
TypeError: 'tuple' object does not support item assignment
t = ('a', 'b', ['A', 'B'])
print(t)
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)
--------
('a', 'b', ['A', 'B'])
('a', 'b', ['X', 'Y'])
在元祖中[‘A’,‘B’]存放的是这个列表的地址,它的地址不能修改,但是这个地址指向的列表内容可以进行修改
表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向’a’,就不能改成指向’b’,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
理解了“指向不变”后,要创建一个内容也不变的tuple怎么做?那就必须保证tuple的每一个元素本身也不能变。
index和count与字符串和列表中的用法相同
>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last): File "" , line 1, in <module> ValueError: tuple.index(x): x notin tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。
字典中的key不可以重复,如果有重复,覆盖之前的值
value可以重复
value可以为空
set:没有值的dict
dict是一个可变类型
若访问不存在的键,则会报错
在我们不确定字典中是否存在某个键而又想获取其值时,可以使用get方法,还可以设置默认值
dict={"a":100,"b":200,"c":300}
print(dict)
print(type(dict))
print(dict["a"])
print(dict.get("b"))
print(dict.get("d")) #'d'键不存在,所以d为None
print(dict.get("d",666)) # 若dict中不存在'd'这个键,就返回默认值666
{'a': 100, 'b': 200, 'c': 300}
<class 'dict'>
100
200
None
666
注:通过key获取元素的value时,可能会有key不存在的情况,就就会报错。
还有一种方式可以获取值: 字典名.get(“key”)
这种方式如果key不存在的话不会报错,接收结果的对象为None 空值
修改元素:
字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改
dict["d"] = 400
print(dict)
dict["d"] = 600
print(dict)
dict["d"] = None
print(dict)
添加元素:
如果在使用 变量名[‘键’] = 数据 时,这个“键”在字典中,不存在,那么就会新增这个元素
删除元素
demo:del删除指定的元素
info = {'name': '班长', 'sex': 'f', 'address': '地球亚洲中国北京'}
print('删除前,%s' % info)
del info['name']
print('删除后,%s' % info)
删除前,{‘name’: ‘班长’, ‘sex’: ‘f’, ‘address’: ‘地球亚洲中国北京’}
删除后,{‘sex’: ‘f’, ‘address’: ‘地球亚洲中国北京’}
demo:del删除整个字典
~~~python
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s'%info)
del info
print('删除后,%s'%info)
# result
删除前,{'name': 'monitor', 'sex': 'f', 'address': 'China'}
demo:clear清空整个字典’
info = {'name': 'monitor', 'sex': 'f', 'address': 'China'}
print('清空前,%s' % info)
info.clear()
print('清空后,%s' % info)
# result
清空前,{'name': 'monitor', 'sex': 'f', 'address': 'China'}
清空后,{}
<1>len()
测量字典中,键值对的个数
<2>keys == map.keySet()
返回一个包含字典所有KEY的列表
<3>values
返回一个包含字典所有value的列表
<4>items
返回一个包含所有(键,值)元祖的列表
<5>has_key (python2.7版本) == in 条件表达式
dict.has_key(key)如果key在字典中,返回True,否则返回False
dict = {"a": 100, "b": 200, "c": 300}
print(len(dict))
print(dict.keys())
print(dict.values())
print(dict.items())
#result
3
dict_keys(['a', 'b', 'c'])
dict_values([100, 200, 300])
dict_items([('a', 100), ('b', 200), ('c', 300)])
dict = {"a": 100, "b": 200, "c": 300}
# 遍历字典的key(键)
for i in dict.keys():
print(i,dict[i])
# 遍历字典的value(值)
for v in dict.values():
print(v)
# 遍历字典的项(元素)
for item in dict.items():
print(item)
# 遍历字典的key-value(键值对)
for i,v in dict.items():
print(i,v)
# result
a 100
b 200
c 300
100
200
300
('a', 100)
('b', 200)
('c', 300)
a 100
b 200
c 300
set集合: 无序 唯一
没有value的字典
# 创建set对象:两种方法
d = {1, 2, 3, 4}
print(type(d))
d1 = set([1, 2, 3, 4]) # 该方法创建时,set()中传的参数必须是list列表类型。
print(d1)
# 给set添加元素
d1.add(5)
print(d1)
-----------------------
<class 'set'>
{1, 2, 3, 4}
{1, 2, 3, 4, 5}
1、请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。
2、和list比较,dict有以下几个特点:
1)查找和插入的速度极快,不会随着key的增加而变慢;
2)需要占用大量的内存,内存浪费多。
3)而list相反:查找和插入的时间随着元素的增加而增加;占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。
3、dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。
要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key
定义函数的格式如下:
def 函数名(): 代码
# 定义一个函数,能够完成打印信息的功能
def printInfo():
print'------------------------------------'
print' 人生苦短,我用Python'
print'------------------------------------'
定义了函数之后,就相当于有了一个具有某些功能的代码,想要让这些代码能够执行,需要调用它
调用函数很简单的,通过 函数名() 即可完成调用
# 定义完函数后,函数是不会自动执行的,需要调用它才可以
printInfo()
def add2num(a, b):
c = a+b
print c
def add2num(a, b):
c = a+b
print c
add2num(11, 22) #调用带有参数的函数时,需要在小括号中,传递数据
函数在定义时可以指定默认值,在调用时如果传了实参则用实参,如果没有则用默认值。
'''
函数由四部分组成
函数名称
函数体
函数参数列表
返回值
1.函数的定义必须要以def开头
2.函数名称+(参数列表)调用
3.函数的参数列表不需要定义类型
4.python的函数没有重载,重名的函数,后面会覆盖前面
5.函数的参数可以带默认值,当调用的时候不指定参数 ,会使用默认值,有参数则覆盖默认值
6.函数调用的时候,可以带有参数名称,此时按照名称进行匹配,不是按照顺序
'''
# 无参的函数
def add():
print("add")
# 带参数的函数
def add(a,b):
print(a+b)
# add() # 会报错,python没有重载的概念,有参数的add已经覆盖掉了无参的add
add(1,2)
# 带默认值参数的函数
def add(a=100,b=200):
print(a+b)
add(1,2) # 1+2=3
add() # 100+200=300 不传参
add(10,) # 10+200=210 只传一个参数
def add(a=100,b=200):
print(a)
print(b)
add(b=1,a=2)
运行结果:
3
3
300
210
2
1
注:带有默认值的参数一定要在参数列表的最后面
>>> def printinfo(name, age=35, sex):
... print name
...
File "" , line 1 SyntaxError: non-default argument follows default argument
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,声明时不会命名。
基本语法如下:
def functionname([formal_args,] *args, **kwargs):"函数_文档字符串"
function_suite
return [expression]
# 不定长的参数
'''
*args:表示一组值的集合,普通数据
**kwargs:表示k-v格式的数据
'''
def fun(a,b,*args,**kwargs):
print("a=",a)
print("b=",b)
print("*args=",args)
print("**kwargs=",kwargs)
for k,v in kwargs.items():
print(k,v)
fun(1,2,3,4,5,6,7,8,9,10,x=1,y=2)
可变类型与不可变类型的变量分别作为函数参数时,会有什么不同吗?
Python有没有类似C语言中的指针传参呢?
list=[1,2,3]
list+=list
print(list)
# 引用传参
a=1
b=[1,2]
def fun(a):
a+=a
print("fun 内:",a)
fun(a) # 值传递
print(a)
fun(b) # 引用传递
print(b)
运行结果:
[1, 2, 3, 1, 2, 3]
fun 内: 2
1
fun 内: [1, 2, 1, 2]
[1, 2, 1, 2]
Python中函数参数是引用传递(注意不是值传递)。
对于不可变类型,因变量不能修改,所以运算不会影响到变量自身;
而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量。
想要在函数中把结果返回给调用者,需要在函数中使用return
return可返回多个值,且返回的值是元组类型。
# 带返回值的函数,可以返回多个返回值
def fun(a,b):
return a+b,a-b,a*b,a/b
a,b,c,d=fun(100,200)
print(a,b,c,d)
----结果----
300 -100 20000 0.5
注:
局部变量(Local variables)指在程序中只在特定过程或函数中可以访问的变量。
总结
如果一个变量,既能在一个函数中使用,也能在其他的函数中使用,这样的变量就是全局变量 定义在函数外。
全局变量可以直接在函数内使用,如果想要修改它的值的话,需要先用globle 对其进行声明。
在方法中不可以修改全局变量的值
'''
1.全局变量可以在方法中使用
2.在方法中不可以改变全局变量的值(加上global可以改变值)
3.不能在global前定义同名的局部变量
'''
count = 100
def fun():
count = 200
print(count)
count = 20
print(count)
print(count)
fun()
print(count)
# 运行结果
100
200
20
100
-----------------------------------
count = 100
def fun():
print(count) # 这里会报错,因为这样写count代表全局变量,当count=20时实际改的是全局变量count,它不会认为你定义了一个新的局部变量,然而在方法中不可以改变全局变量的值
count = 20
print(count)
print(count)
fun()
print(count)
-----------------
count = 100
def fun():
count = 200 # 这里会报错,不能在global前定义同名的局部变量
print(count)
global count # 声明global后就代表这个变量是一个全局变量,不在和局部变量有关系
print(count)
count = 20
print(count)
print(count)
fun()
print(count)
总结一:
总结二:
在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。
# 递归函数
'''
斐波那契数列
1,1,2,3,5,8,13...
'''
def getNum(a):
if(a<=2):
return 1
else:
return getNum(a-1)+getNum(a-2)
print(getNum(10))
for i in range(1,11):
print(getNum(i),end='\t')
55
1 1 2 3 5 8 13 21 34 55
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:
expression
例子
# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数
print("Value of total : ", sum(10, 20))
print("Value of total : ", sum(20, 20))
Value of total : 30
Value of total : 40
Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print,因为lambda需要一个表达式
'''
用途
1.当做函数的参数
2.当作内置参数使用
'''
# 当做函数的参数
def fun(a, b, opt):
print("a=", a)
print("b=", b)
print("result=", opt(a, b))
fun(1, 2, lambda a, b: a + b)
fun(1, 2, lambda a, b: a - b)
fun(1, 2, lambda a, b: a * b)
fun(1, 2, lambda a, b: a / b)
# 当作内置参数使用
stus = [{"name": "zhangsan", "age": 18}, {"name": "lisi", "age": 19}, {"name": "wangwu", "age": 17}]
print(stus)
stus.sort(key=lambda x: x['name'])
print("按name排序:", stus)
stus.sort(key=lambda x: x['age'])
print("按age排序:", stus)
# 运行结果
a= 1
b= 2
result= 3
a= 1
b= 2
result= -1
a= 1
b= 2
result= 2
a= 1
b= 2
result= 0.5
[{'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}]
按name排序: [{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]
按age排序: [{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]
'''
写一个计算器程序:用循环封装,从控制台输入数据和运算符,能够从控制台退出。
'''
# 进行运算的函数
def operator(num1, num2, opt):
num1 = int(num1)
num2 = int(num2)
if (opt == "+"):
return num1 + num2
elif (opt == "-"):
return num1 - num2
elif (opt == "*"):
return num1 * num2
elif (opt == "/"):
return num1 / num2
# 判断数据是否符合要求
def judgeNum(num, id):
if (num == "q"):
return False
elif (num.isdigit() == False):
while (True):
print("输入错误!请重新输入第[", id, "]位数据")
num = input("请输入数据:")
if (num.isdigit()):
break
elif (num == "q"):
return False
return num
# 判断操作符是否符合要求
def judgeOpt(opt):
if (opt not in ["+", "-", "*", "/"]):
while (True):
print("操作符不符合要求,应为:[+,-,*,/]中的一个")
opt = input("请重新输入操作符:")
if (opt in ["+", "-", "*", "/"]):
return opt
else:
return opt
while (True):
n1 = input("请输入数据1:")
n1 = judgeNum(n1, 1)
if (n1 == False):
break
n2 = input("请输入数据2:")
n2 = judgeNum(n2, 2)
if (n2 == False):
break
opt = input("请输入操作符:")
opt = judgeOpt(opt)
result = operator(n1, n2, opt)
print("%s%s%s=%s" % (n1, opt, n2, result));
想一想:如果想用word编写一份简历,应该有哪些流程呢?
1、打开word软件,新建一个word文件
2、写入个人简历信息
3、保存文件
4、关闭word软件
同样,在操作文件的整体过程与使用word编写一份简历的过程是很相似的 (io操作)
1、打开文件,或者新建立一个文件
2、读/写数据
3、关闭文件
在python,使用open函数,可以打开一个已经存在的文件,或者创建一个新文件
open(文件名,访问模式)
open默认模式是r只读模式
f = open(r'd:\nata\test.txt', 'w') r:标志在后面的均为普通字符
访问模式说明:
访问模式 | 说明 |
---|---|
r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。 |
a | 打开一个文件用于**追加**。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。 |
ab | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。 |
a+ | 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。 |
rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。 |
ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。 |
close( )
示例如下:
# 新建一个文件,文件名为:
test.txt f = open('test.txt', 'w') # 关闭这个文件
f.close()
使用write()可以完成向文件写入数据
# 写(如果存在则覆盖,不存在文件则创建文件再写入)
f=open("d://wc.txt","w")
f.write("abc")
f.close()
# 写(如果存在则追加,不存在文件则创建文件再写入)
f=open("d://wc.txt","a")
f.write("abc")
f.close()
read(int num) 指定文件读取的字节数
使用read(num)可以从文件中读取数据,num表示要从文件中读取的数据的长度(单位是字节),如果没有传入num,那么就表示读取文件中所有的数据
f = open('test.txt', 'r')
content = f.read(1024)
print(content)
print("-"*30)
content = f.read()
print(content)
f.close()
注意:如果open是打开一个文件,那么可以不用写打开的模式,即只写 open(‘test.txt’),如果使用读了多次,那么后面读取的数据是从上次读完后的位置开始的
只读取一行文件内容
#coding=utf-8
f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
f.close()
就像read没有参数时一样,readlines可以按照行的方式把整个文件中的内容进行一次性读取,并且返回的是一个列表,其中每一行的数据为一个元素
#coding=utf-8
f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
print("%d:%s"%(i, temp))
i+=1
f.close()
f=open("d://wc.txt")
# 读取所有文件内容
# content=f.read()
# 读取一行文件内容
# content=f.readline()
# 读取多行文件内容\
content=f.readlines()
for i in content:
print(i)
f.close()
在读写文件的过程中,如果想知道当前的位置,可以使用tell()来获取
wc.txt
abc hello world
hive hbase spark
python hadoop scala
impala
# 获取文件读取的位置
f=open("d://wc.txt")
print(f.readline())
print(f.tell())
f.close()
运行结果为:
abc hello world
17 # abc hello world共15个字节, 换行符\n两个字节
# 打开一个已经存在的文件
f = open("d://wc.txt", "r")
str = f.read(3)
print("读取的数据是 : ", str)
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
str = f.read(3)
print("读取的数据是 : ", str)
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
f.close()
读取的数据是 : abc
当前文件位置 : 3
读取的数据是 : he
当前文件位置 : 6
如果在读写文件的过程中,需要从另外一个位置进行操作的话,可以使用seek()
seek(offset, from)有2个参数
abc hello world
hive hbase spark
python hadoop scala
impala
f = open("d://wc.txt", "r")
f.seek(5,0)
print(f.readline()) # ello world
f.close()
demo:把位置设置为:从文件开头,偏移5个字节
# 打开一个已经存在的文件
f = open("d://wc.txt", "r")
str = f.read(30)
print("读取的数据是 : ", str)
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
# 重新设置位置
f.seek(5,0)
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
f.close()
# 运行结果
读取的数据是 : abc hello world
hive hbase spa
当前文件位置 : 31
当前文件位置 : 5
demo:把位置设置为:离文件末尾,3字节处
# 打开一个已经存在的文件
f = open("d://wc.txt", "rb")
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
# 重新设置位置
f.seek(-3,2)
# 读取到的数据为:文件最后3个字节数据
str = f.read()
print("读取的数据是 : ", str)
f.close()
# 运行结果
当前文件位置 : 0
读取的数据是 : b'ala'
有些时候,需要对文件进行重命名、删除等操作,python的os模块中都有这么功能
import os
python编程时,经常和文件、目录打交道,这是就离不了os模块。os模块包含普遍的操作系统功能,与具体的平台无关。以下列举常用的命令
os.name()——判断现在正在使用的平台,Windows 返回 ‘nt’; Linux 返回’posix’
rename(需要修改的文件名, 新的文件名) 也可以做剪切。
os.getcwd()——得到当前工作的目录。
os.listdir()——指定所有目录下所有的文件和目录名。
以列表的形式全部列举出来,其中没有区分目录和文件。
os.remove()——删除指定文件
os.rmdir()——删除指定目录 :该目录不能为空
os.mkdir()——创建目录
注意:这样只能建立一层,要想递归建立可用:os.makedirs(x/y/z)
os.path.isfile()——判断指定对象是否为文件。是返回True,否则False
os.path.isdir()——判断指定对象是否为目录。是True,否则False。例:
os.path.exists()——检验指定的对象是否存在。是True,否则False.例:
os.getcwd()——获得当前工作的目录(get current work dir)
os.system()——执行shell命令。例:
**注意**:此处运行shell命令时,如果要调用python之前的变量,可以用如下方式:
```shell
var=123
os.environ['var']=str(var) //注意此处[]内得是 “字符串”
os.system('echo $var')
```
os.chdir()——改变目录到指定目录
os.path.getsize()——获得文件的大小,如果为目录,返回0
os.path.abspath()——获得绝对路径。例:
os.path.join(path, name)——连接目录和文件名。例:
os.path.basename(path)——返回文件名
os.path.dirname(path)——返回文件所在目录
import os
print(os.name)
print(os.listdir())
print(os.getcwd())
# os.remove("d://wc.txt")
# os.mkdir("d://abc")
print(os.path.isfile("d://abc"))
print(os.path.isdir("d://abc"))
os.system("echo 'java -version'")
os.system("java -version")
os.system("dir")
f=open("d:\wc.txt","w") # 适用于windows和linux
f.write("python")
f.close()
f=open("d://wc.txt","w") # 只适用于windows
f.write("python")
f.close()
f=open("d:\test.txt","w") # 这样写程序会认为\t是制表符
f.write("python")
f.close()
# 解决以上问题,有两种方法
f=open("d:\\test.txt","w") # 遇到转义字符可以多加一个\
f.write("python")
f.close()
f=open(r"d:\test.txt","w") # 在路径前加一个r:表示""内的字符表示其本身自己的含义
f.write("python")
f.close()