环境准备
下载:https://www.python.org/
Windows版本使用python.msi
类UNIX系统默认已经安装,或使用源码包
# ./configure
# make
# make install
[root@python 桌面]# python //进入python环境
>>> quit() //退出python环境,也可用快捷键Ctrl+D退出
查看帮助命令:>>> help(命令) 如:help(rlcompleter)
第一步:一开始不能使用tab补全功能,需要编写自动补全脚本tab.py
# vim /usr/local/bin/tab.py
#!/usr/bin/env python //因为没有环境变量,给tab.sh用
import readline
import rlcompleter
readline.parse_and_bind('tab: complete')
扩展:
#!/usr/bin/env python
import sys
import readline
import rlcompleter
import atexit
import os
readline.parse_and_bind('tab: complete')
histfile = os.path.join(os.environ['HOME'], '.pythonhistory')
try:
readline.read_history_file(histfile)
except IOError:
pass
atexit.register(readline.write_history_file,histfile)
del os, histfile, readline, rlcompleter
第二步:设置环境变量
# vim ~/.bash_profile
PYTHONSTARTUP=/usr/local/bin/tab.py
export PYTHONSTARTUP
# source ~/.bash_profile
第三步:编写tab.sh脚本,设置python环境变量开机自启
#!/bin/bash
#Summary:Enable tab complete for python
#Description:
# Needs import readline and rlcompleter module
# import readline
# import rlcompleter
# help(rlcompleter) display detail: readline.parse_and_bind('tab: complete')
# man python display detail: PYTHONSTARTUP variable
[ ! -f /usr/bin/tab.py ]&& cp ./tab.py /usr/bin/
sed -i '$a export PYTHONSTARTUP=/usr/bin/tab.py' /etc/profile
source /etc/profile
命令+shell语法
Python语法+模块
python【数据分析,网站,电影,书】
win python
linux python
调用模块【积木】
查看python版本 : python -V //也可以在交互式编程模式,查看版本:# python
帮助
1. 列出模块中的函数
用import导出模块后,可使用函数dir(m)列出模块的所有函数,import是导出模块的命令,m是模块名。
>>>import math
>>>dir(math) //math模块的一些函数,以双下划线( _ _ )开头的名称用于较复杂的python编程。
2.查看完整的python内置函数清单,可在提示符后输入 >>>dir(_ _builtins_ _)。
>>> dir(__builtins__)
3. 查看某个函数的文档帮助信息
>>>help(函数名)
Python 环境变量
下面几个重要的环境变量,它应用于Python:
变量名 描述
PYTHONPATH PYTHONPATH是Python搜索路径,默认我们import的模块都会从PYTHONPATH里面寻找。
PYTHONSTARTUP Python启动后,先寻找PYTHONSTARTUP环境变量,然后执行此文件中变量指定的执行代码。
PYTHONCASEOK 加入PYTHONCASEOK的环境变量, 就会使python导入模块的时候不区分大小写.
PYTHONHOME 另一种模块搜索路径。它通常内嵌于的PYTHONSTARTUP或PYTHONPATH目录中,使得两个模块库更容易切换。
运行Python
有三种方式可以运行Python:
1、交互式解释器:
你可以通过命令行窗口进入python并开在交互式解释器中开始编写Python代码。
你可以在Unix,DOS或任何其他提供了命令行或者shell的系统进行python编码工作。
$ python # Unix/Linux
或者
C:>python # Windows/DOS
以下为Python命令行参数:
选项 描述
-d 在解析时显示调试信息
-O 生成优化代码 ( .pyo 文件 )
-S 启动时不引入查找Python路径的位置
-V 输出Python版本号
-X 从 1.6版本之后基于内建的异常(仅仅用于字符串)已过时。
-c cmd 执行 Python 脚本,并将运行结果作为 cmd 字符串。
file 在给定的python文件执行python脚本。
2、命令行脚本
在你的应用程序中通过引入解释器可以在命令行中执行Python脚本,如下所示:
$ python script.py # Unix/Linux
或者
C:>python script.py # Windows/DOS
注意:在执行脚本时,请检查脚本是否有可执行权限。
3、集成开发环境(IDE:Integrated Development Environment): PyCharm
PyCharm 是由 JetBrains 打造的一款 Python IDE,支持 macOS、 Windows、 Linux 系统。
支持的功能有:调试、语法高亮; Project管理、代码跳转
智能提示、自动完成; 单元测试、版本控制
下载地址:https://www.jetbrains.com/pycharm/download
少量书写代码可直接在命令行执行,但如果大量书写脚本代码时,需要使用pycharm,它能实时保存,保证数据不会丢失
示例:脚本hello.py,输出"Hello World!"
#!/usr/bin/python3
print("Hello, World!");
验证:#python hello.py
Python 中文编码
用 Python 输出 "Hello, World!",英文没有问题,但是如果你输出中文字符"你好,世界"就有可能会碰到中文编码问题,在执行过程会出现报错:
#!/usr/bin/python
print "你好,世界";
以上程序执行输出结果为:
File "test.py", line 2
SyntaxError: Non-ASCII character '\xe4' in file test.py on line 2, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
Python中默认的编码格式是 ASCII 格式,在没修改编码格式时无法正确打印汉字,所以在读取中文时会报错。
解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了
注意:#coding=utf-8 的 = 号两边不要空格。
注意:Python3.X 源码文件默认使用utf-8编码,所以可以正常解析中文,无需指定 UTF-8 编码。
注意:如果你使用编辑器,同时需要设置 py 文件存储的格式为 UTF-8,否则会出现类似以下错误信息:
SyntaxError: (unicode error) ‘utf-8’ codec can’t decode byte 0xc4 in position 0:
invalid continuation byte
Pycharm 设置步骤:
进入 file > Settings,在输入框搜索 encoding。
找到 Editor > File encodings,将 IDE Encoding 和 Project Encoding 设置为utf-8。
//其实pycharm右下角就可以切换编码,不用这么麻烦。但是,如果你文件已经指定了编码 # -*- coding: UTF-8 -*-,这里就不能修改了。
脚本语言的第一行,目的就是指出,你想要你的这个文件中的代码用什么可执行程序去运行它,就这么简单。
#!/usr/bin/python : 是告诉操作系统执行这个脚本的时候,调用 /usr/bin 下的 python 解释器;
#!/usr/bin/env python(推荐): 这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候,首先会到 env 设置里查找 python 的安装路径,再调用对应路径下的解释器程序完成操作。
#!/usr/bin/python 相当于写死了python路径;
#!/usr/bin/env python 会去环境设置寻找 python 目录,推荐这种写法
Python语法结构
Python 标识符
在 Python 里,标识符由字母、数字、下划线组成。
在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入;
以双下划线开头的 __foo 代表类的私有成员;以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识,如 __init__() 代表类的构造函数。
Python 可以同一行显示多条语句,方法是用分号 ; 分开,如:
>>> print 'hello';print 'runoob';
Python 保留字符
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数,或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。
and |
exec |
not |
assert |
finally |
or |
break |
for |
pass |
class |
from |
|
continue |
global |
raise |
def |
if |
return |
del |
import |
try |
elif |
in |
while |
else |
is |
with |
except |
lambda |
yield |
语句块缩进:
Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字,让代码看起来整洁美观。它不像其他的静态语言如C、Pascal那样需要重复书写声明语句,也不像它们的语法那样经常有特殊情况和意外。
语句块缩进:
Python开发者有意让违反了缩进规则的程序不能通过编译,以此来强制程序员养成良好的编程习惯。并且Python语言利用缩进表示语句块的开始和退出(Off-side规则),而非使用花括号或者某种关键字。增加缩进表示语句块的开始,而减少缩进则表示语句块的退出。缩进成为了语法的一部分。缩进表达一个语句属于哪个代码块。
缩进风格:1或2:可能不够,很难确定代码语句属于哪个块
8到10:可能太多,如果代码内嵌的层次太多,就会使得代码很难阅读
4个空格:非常流行,范·罗萨姆支持的风格
示例:
>>> if 3>2:
... print "OK"
File "<stdin>", line 2
print "OK"
^
IndentationError: expected an indented block //报错,缩进有问题
>>> if 3>2:
... print "OK"
... print "yes"
File "<stdin>", line 3
print "yes"
^
IndentationError: unindent does not match any outer indentation level
报错回报:
IndentationError: unexpected indent 错误是 python 编译器是在告诉你"Hi,老兄,你的文件里格式不对了,可能是tab和空格没对齐的问题"。
IndentationError: unindent does not match any outer indentation level错误表明,你使用的缩进方式不一致,有的是 tab 键缩进,有的是空格缩进,改为一致即可。
因此,在 Python 的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用
程序输出——Print将数据输出到屏幕:
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上逗号
“,”表示空格,“+”表示不空格
>>> print 'Hello World!'
>>> print 'Hello','World' //字符间有一个空格
//此命令等价于>>> print 'Hello', 与 >>> print 'World',两条命令
>>> print 'Hello'+'World' //字符间无空格
程序输入——使用raw_input()函数读取用户输入数据
>>> user=raw_input('Enter your name:')
Enter your name:bob
>>> print 'Your name is :',user
Your name is : bob
>>> i=raw_input('Input a number:')
Input a number:10
>>> i+1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
需要注意的是,raw_input()函数读入的数据全部是以字符串的方式存储的。如果用户输的是数字,那么python也将其保存为字符串,当将字符串与数字做数学运算是将会出现TypeError的错误。
因此,在 Python 的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用。
示例:编写login.py脚本,实现:提示用户输入用户名;将用户名保存在变量中,在屏幕上显示欢迎用户的信息
[root@py01 bin]# vim /root/bin/login.py
#!/usr/bin/env python
#coding:utf-8 //支持中文输入
username = raw_input('username: ') #使用变量username接收用户输入的字符
print 'Welcome', username #输出欢迎信息,字符串和变量名之间用逗号隔开
#两者之间自动会加上空格
# chmod +x login.py #给脚本添加执行权限
# ./login.py //输入用户名,查看回显
多行语句:Python语句中一般以新行作为为语句的结束符。
但是我们可以使用斜杠( \)将一行的语句分为多行显示,如下所示:
total = item_one + \
item_two + \
item_three
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例:
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
注释:和大部分脚本及Unix-shell语言一样,python也使用#符号标示注释
从#开始,直到一行结束的内容都是注释
注释可以在语句或表达式行末,如:name = "Tom" # 这是一个注释
良好的注释习惯可以:方便其他人了解程序功能;方便自己在日后读懂代码
文档字符串:可以当作一种特殊的注释
在模块、类或者函数的起始添加一个字符串,起到在线文档的功能
简单的说明可以使用单引号或双引号,无区别
较长的文字说明可以使用三引号,在文件的特定地点,被当作注释使用。
Python空行
函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。
空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
记住:空行也是程序代码的一部分。
下面的程序执行后就会等待用户输入,按回车键后就会退出:
#!/usr/bin/python
raw_input("\n\nPress the enter key to exit.")
以上代码中 ,"\n\n"在结果输出前会输出两个新的空行。一旦用户按下 enter(回车) 键退出,其它键显示。
同一行显示多条语句
Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,以下是一个简单的实例:
#!/usr/bin/python
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
执行以上代码,输入结果为:
$ python test.py
runoob
示例:编写python函数模块
调用模块:python进入环境--->直接输入脚本名.函数名()或者变量,如test.star()/a
[root@svr7 ~]# cat star.py
#!/usr/bin/python
#coding:utf-8
'''这是一个模块
主要是测试使用'''
hi='hello the world'
def star():
''' 这是一个函数
用来打印星星'''
print '*'*20
print 'ok'
将函数模块导入到项目库中:先cd进入项目库中,进入python环境,
执行脚本传入参数,使用sys模块,编辑 test.py 如下
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import sys
print sys.argv
sys.argv 用来获取命令行参数
运行命令,执行结果:
./test.py hello
['./test.py', 'hello']
sys.argv[0] 代表文件本身路径,所带参数从 sys.argv[1] 开始。
Python变量
变量定义
变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
//基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。
//因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。
变量名称约定:第一个字符只能是大小写字母或下划线
后续字符只能是大小写字母或数字或下划线
区分大小写
Python是动态类型语言,即不需要预先声明变量的类型
变量赋值
每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。
每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
变量的类型和值在赋值那一刻被初始化
等号(=)用来给变量赋值。
等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。
Python也支持增量赋值,如 :n+=1 不能使用i++
多个变量赋值
Python允许你同时为多个变量赋值。例如:a = b = c = 1
以上实例,创建一个整型对象,值为1,三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如:a, b, c = 1, 2, "john"
以上实例,两个整型对象1和2的分配给变量 a 和 b,字符串对象 "john" 分配给变量 c。
Python的表达式写法与C/C++类似。只是在某些写法有所差别。
运算符
标准算术运算符:假设变量:a=10,b=20
运算符 |
描述 |
实例 |
+ |
加 - 两个对象相加(或者取正) |
a + b 输出结果 30 |
- |
减 - 得到负数或是一个数减去另一个数 |
a - b 输出结果 -10 |
* |
乘 - 两个数相乘或是返回一个被重复若干次的字符串 |
a * b 输出结果 200 |
/ |
除 - x除以y |
b / a 输出结果 2 |
% |
取模 - 返回除法的余数 |
b % a 输出结果 0 |
** |
幂 - 返回x的y次幂 |
a**b 为10的20次方, 输出结果 100000000000000000000 |
// |
取整除 - 返回商的整数部分 |
9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
~ |
取补 |
注意:Python2.x 里,整数除整数,只能得出整数。如果要得到小数部分,把其中一个数改成浮点数即可
比较运算符:假设变量:a=10,b=20
运算符 |
描述 |
实例 |
== |
等于 - 比较对象是否相等 |
(a == b) 返回 False。 |
!= |
不等于- 比较两个对象是否不相等 |
(a != b) 返回 true. |
<> |
不等于 - 比较两个对象是否不相等 |
(a <> b) 返回 true。这个运算符类似 != 。 |
> |
大于 - 返回x是否大于y |
(a > b) 返回 False。 |
< |
小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。 |
(a < b) 返回 true。 |
>= |
大于等于- 返回x是否大于等于y。 |
(a >= b) 返回 False。 |
<= |
小于等于- 返回x是否小于等于y。 |
(a <= b) 返回 true。 |
赋值运算符:假设变量:a=10,b=20
运算符 |
描述 |
实例 |
= |
简单的赋值运算符 |
c = a + b 将 a + b 的运算结果赋值为 c |
+= |
加法赋值运算符 |
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 |
位运算符:假设变量:a=60,b=12
运算符 |
描述 |
实例 |
& |
按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 |
(a & b) 输出结果 12 ,二进制解释: 0000 1100 |
| |
按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 |
(a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ |
按位异或运算符:当两对应的二进位相异时,结果为1 |
(a ^ b) 输出结果 49 ,二进制解释: 0011 0001 |
~ |
按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 |
(~a ) 输出结果 -61 ,二进制解释: 1100 0011,在一个有符号二进制数的补码形式。 |
<< |
左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 |
a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> |
右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数 |
a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
逻辑运算符:假设变量:a=10,b=20
运算符 |
逻辑表达式 |
描述 |
实例 |
and |
x and y |
布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 |
(a and b) 返回 20。 |
or |
x or y |
布尔"或" - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。 |
(a or b) 返回 10。 |
not |
not x |
布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 |
not(a and b) 返回 False |
成员运算符:成员,包括字符串,列表或元组。用于判断一个对象是否属于另外一个对象。
运算符 |
描述 |
实例 |
in |
如果在指定的序列中找到值返回 True,否则返回 False。 |
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in |
如果在指定的序列中没有找到值返回 True,否则返回 False。 |
x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
if ( a in list ):
print "变量 a 在给定的列表中 list 中"
else:
print "变量 a 不在给定的列表中 list 中"
身份运算符:用于比较两个对象的存储单元是否为同一对象
运算符 |
描述 |
实例 |
is |
is 是判断两个标识符是不是引用自一个对象 |
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not |
是判断两个标识符是不是引用自不同对象 |
x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
注: id() 函数用于获取对象内存地址。
is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
运算符优先级:以下表格列出了从最高到最低优先级的所有运算符
运算符 |
描述 |
** |
指数 (最高优先级) |
~ + - |
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // |
乘,除,取模和取整除 |
+ - |
加法减法 |
>> << |
右移,左移运算符 |
& |
位 'AND' |
^ | |
位运算符 |
<= < > >= |
比较运算符 |
<> == != |
等于运算符 |
= %= /= //= -= += *= **= |
赋值运算符 |
is is not |
身份运算符 |
in not in |
成员运算符 |
not or and |
逻辑运算符 |
在这些运算符里面,~, |, ^, &, <<, >>必须应用于整数。
以下实例演示了Python所有运算符优先级的操作:
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print "(a + b) * c / d 运算结果为:", e
e = ((a + b) * c) / d # (30 * 15 ) / 5
print "((a + b) * c) / d 运算结果为:", e
e = (a + b) * (c / d); # (30) * (15/5)
print "(a + b) * (c / d) 运算结果为:", e
e = a + (b * c) / d; # 20 + (150/5)
print "a + (b * c) / d 运算结果为:", e
以上实例输出结果:
(a + b) * c / d 运算结果为: 90
((a + b) * c) / d 运算结果为: 90
(a + b) * (c / d) 运算结果为: 90
a + (b * c) / d 运算结果为: 50
标准数据类型
在内存中存储的数据可以有多种类型。
例如,一个人的年龄可以用数字来存储,他的名字可以用字符来存储。
Python 定义了一些标准类型,用于存储各种类型的数据。
Python有五个标准的数据类型:
数字Numbers
数字数据类型用于存储数值。
他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。
数字表示方式:python默认以十进制数显示
数字以0开头表示8进制数
数字以0x或0X开头表示16进制数
数字以0b或0B开头表示2进制数
基本数字类型:int:有符号整数 long:长整数[也可以代表八进制和十六进制]
float:浮点数 complex:复数
bool:布尔值 True:1 False:0
长整型也可以使用小写 l,但是还是建议您使用大写 L,避免与数字 1 混淆。Python使用 L 来显示长整型。
Python 还支持复数,复数由实数部分和虚数部分构成,可以用 a + bj,或者 complex(a,b) 表示, 复数的实部 a 和虚部 b 都是浮点型。
一些数值类型的实例:
int |
long |
float |
complex |
10 |
51924361L |
0.0 |
3.14j |
100 |
-0x19323L |
15.20 |
45.j |
-786 |
0122L |
-21.9 |
9.322e-36j |
080 |
0xDEFABCECBDAECBFBAEl |
32.3e+18 |
.876j |
-0490 |
535633629843L |
-90. |
-.6545+0J |
-0x260 |
-052318172735L |
-32.54e100 |
3e+26J |
0x69 |
-4721885298529L |
70.2E-12 |
4.53e-7j |
当你指定一个值时,Number对象就会被创建:var1 = 1
您也可以使用del语句删除一些对象的引用。
del语句的语法是:del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象的引用。例如:del var、del var_a, var_b
示例:python修改文件权限
[root@python 项目库]python //进入全局
>>> import os
>>> os.chmod("test.py",0777) //os.chmod('文件路径',0777/其他权限)
**//文件权限为8进制,修改文件权限时要注意这一点。
字符串String
定义字符串:python中字符串被定义为引号之间的字符集合
是由数字、字母、下划线组成的一串字符
Python支持使用成对的单引号或双引号
无论单引号,还是双引号,表示的意义相同
Python还支持三引号(三个连续的单引号或双引号),可以用来包含特殊字符
Python不区分字符和字符串
一般记为 :s="a1a2···an"(n>=0) //它是编程语言中表示文本的数据类型。
字符串的操作有基本的功能不需要再自己进行拼接遍历的操作。
字符串切片:使用索引运算符[]和切片运算符[:]可得到子字符串
第一个字符的索引是0,最后一个字符的索引是-1
子字符串包含切片中的起始下标,但不包含结束下标
//回顾shell的切片:echo ${a:0:3} expr
python的字串列表有2种取值顺序:
从左到右索引:默认0开始的,最大范围是字符串长度少1
从右到左索引:默认-1开始的,最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话,可以使用变量 [头下标:尾下标],就可以截取相应的字符串,其中下标是从 0 开始算起,可以是正数或负数,下标可以为空表示取到头或尾。比如:s = 'ilovepython' , s[1:5]的结果是love。
当使用以冒号分隔的字符串,python返回一个新的对象,结果包含了以这对偏移标识的连续的内容,左边的开始是包含了下边界。
上面的结果包含了s[1]的值l,而取到的最大范围不包括上边界,就是s[5]的值p。
字符串连接操作:加号(+)是字符串连接运算符,星号(*)是重复操作。
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = 'Hello World!'
print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第五个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串
以上实例输出结果:
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
待验证:????????
输出第2位到结尾的字符串:ab[2:](区间)
输出第2位开始(起始下标包括)到第5位(最后一位结束下标不包含)的字符串:ab[2:5]
列表List—— Python 中使用最频繁的数据类型
定义列表:可以将列表当成普通的“数组”,它能保存任意数量任意类型的python对象
像字符串一样,列表也支持下标和切片操作
列表中的项目可以改变
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。
列表用 [ ] 标识,是 python 最通用的复合数据类型。类似 C 语言中的数组。
列表中值的切割也可以用到变量 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。
加号 + 是列表连接运算符,星号 * 是重复操作。如下实例:
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list # 输出完整列表
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个的元素
print list[2:] # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表
以上实例输出结果:
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
列表操作:使用in或not in判断成员关系
使用append方法向列表中追加元素
>>> a.append('xiaowu')
>>>22 in a
元组Tuple,可以认为元组是“静态”的列表,元组一旦定义,不能改变
元组定义:a=(1,'tom')---a[0]=2不允许改变
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print tuple # 输出完整元组
print tuple[0] # 输出元组的第一个元素
print tuple[1:3] # 输出第二个至第三个的元素
print tuple[2:] # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2 # 输出元组两次
print tuple + tinytuple # 打印组合的元组
以上实例输出结果:
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')
以下是元组无效的,因为元组是不允许更新的。而列表是允许更新的:
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000 # 元组中是非法应用
list[2] = 1000 # 列表中是合法应用
字典Dictionary,是由键-值(key-value)对构成的映射数据类型,通过键取值,可创建键-值,不支持下标操作
>>>a={'name':'xieruixian','age':22,'heitht':1.78}
>>>a['name']
>>>'name' in a
>>>a{'wei':128}
>>> a.get('weight',130)----->130
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值
输出结果为:
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']
数据类型比较
按存储模型分类:标量类型:数值、字符串
容器类型:列表、元组、字典
按更新模型分类:可变类型:列表、字典
不可变类型:数字、字符串、元组
按访问模型分类:直接访问:数字
顺序访问:字符串、列表、元组
映射访问:字典
Python数据类型转换
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。
函数 |
描述 |
int(x [,base]) |
将x转换为一个整数 |
long(x [,base] ) |
将x转换为一个长整数 |
float(x) |
将x转换到一个浮点数 |
complex(real [,imag]) |
创建一个复数 |
str(x) |
将对象 x 转换为字符串 |
repr(x) |
将对象 x 转换为表达式字符串 |
eval(str) |
用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s) |
将序列 s 转换为一个元组 |
list(s) |
将序列 s 转换为一个列表 |
set(s) |
转换为可变集合 |
dict(d) |
创建一个字典。d 必须是一个序列 (key,value)元组。 |
frozenset(s) |
转换为不可变集合 |
chr(x) |
将一个整数转换为一个字符 |
unichr(x) |
将一个整数转换为Unicode字符 |
ord(x) |
将一个字符转换为它的整数值 |
hex(x) |
将一个整数转换为一个十六进制字符串 |
oct(x) |
将一个整数转换为一个八进制字符串 |
表达式
Python支持“列表推导式”(list comprehension),比如计算0-9的平方和:
>>> sum(x * x for x in range(10))
285
Python使用lambda表示匿名函数。匿名函数体只能是表达式。比如:
>>> add=lambda x, y : x + y
>>> add(3,2)
5
Python使用y if cond else x表示条件表达式。意思是当cond为真时,表达式的值为y,否则表达式的值为x。相当于C++和Java里的cond?y:x。
Python区分列表(list)和元组(tuple)两种类型。list的写法是[1,2,3],而tuple的写法是(1,2,3)。可以改变list中的元素,而不能改变tuple。在某些情况下,tuple的括号可以省略。tuple对于赋值语句有特殊的处理。因此,可以同时赋值给多个变量,比如:
>>> x, y=1,2#同时给x,y赋值,最终结果:x=1, y=2
特别地,可以使用以下这种形式来交换两个变量的值:
>>> x, y=y, x #最终结果:y=1, x=2
Python使用'(单引号)和"(双引号)来表示字符串。与Perl、Unix Shell语言或者Ruby、Groovy等语言不一样,两种符号作用相同。一般地,如果字符串中出现了双引号,就使用单引号来表示字符串;反之则使用双引号。如果都没有出现,就依个人喜好选择。出现在字符串中的\(反斜杠)被解释为特殊字符,比如\n表示换行符。表达式前加r指示Python不解释字符串中出现的\。这种写法通常用于编写正则表达式或者Windows文件路径。
Python支持列表切割(list slices),可以取得完整列表的一部分。支持切割操作的类型有str, bytes, list, tuple等。它的语法是...[left:right]或者...[left:right:stride]。假定nums变量的值是[1, 3, 5, 7, 8, 13, 20],那么下面几个语句为真:
nums[2:5] == [5, 7, 8] 从下标为2的元素切割到下标为5的元素,但不包含下标为5的元素。
nums[1:] == [3, 5, 7, 8, 13, 20] 切割到最后一个元素。
nums[:-3] == [1, 3, 5, 7] 从最开始的元素一直切割到倒数第3个元素。
nums[:] == [1, 3, 5, 7, 8, 13, 20] 返回所有元素。改变新的列表不会影响到nums。
nums[1:5:2] == [3, 7] 从下标为1的元素切割到下标为5的元素但不包含下标为5的元素,且步长为2。
数学运算
Python使用与C、Java类似的运算符,支持整数与浮点数的数学运算。同时还支持复数运算与无穷位数(实际受限于计算机的能力)的整数运算。除了求绝对值函数abs()外,大多数数学函数处于math和cmath模块内。前者用于实数运算,而后者用于复数运算。使用时需要先导入它们,比如:
>>> import math
>>> print(math.sin(math.pi/2))
1.0
fractions模块用于支持分数运算;decimal模块用于支持高精度的浮点数运算。
Python定义求余运行a % b的值处于开区间[0, b)内,如果b是负数,开区间变为(b, 0]。这是一个很常见的定义方式。不过其实它依赖于整除的定义。为了让方程式:b * (a // b) + a % b = a恒真,整除运行需要向负无穷小方向取值。比如7 // 3的结果是2,而(-7) // 3的结果却是-3。这个算法与其它很多编程语言不一样,需要注意,它们的整除运算会向0的方向取值。
Python允许像数学的常用写法那样连着写两个比较运行符。比如a < b < c与a < b and b < c等价。C++的结果与Python不一样,首先它会先计算a < b,根据两者的大小获得0或者1两个值之一,然后再与c进行比较。