关闭

嵌入式 python基本语法一

962人阅读 评论(0) 收藏 举报
分类:

Python 基础语法(一)

Python的特点

  1. 简单

    Python是一种代表简单思想的语言。

  2. 易学

    Python有极其简单的语法。

  3. 免费、开源

    Python是FLOSS(自由/开放源码软件)之一。

  4. 高层语言

    使用Python编写程序时无需考虑如何管理程序使用的内存一类的底层细节。

  5. 可移植性

    Python已被移植到很多平台,这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、

  BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、

  Windows CE甚至还有PocketPC。

  6. 解释性

    可以直接从源代码运行。在计算机内部,python解释器把源代码转换为字节码的中间形式,然后再把它翻译成计算机使用的机器语言。

  7. 面向对象

    Python既支持面向过程编程也支持面向对象编程。

  8. 可扩展性

    部分程序可以使用其他语言编写,如c/c++。

  9. 可嵌入型

    可以把Python嵌入到c/c++程序中,从而提供脚本功能。

  10. 丰富的库

    Python标准库确实很庞大。它可以帮助你处理各种工作,包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、

  电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI(图形用户界面)、Tk和其他与系统有关的操作。

 

---------------分割线------------------------以下是Python的基本语法---------------------------------------------------------

一、基本概念

  1. python中数有四种类型:整数、长整数、浮点数和复数。

  • 整数, 如 1
  • 长整数 是比较大的整数
  • 浮点数 如 1.23、3E-2
  • 复数 如 1 + 2j、 1.1 + 2.2j

  2. 字符串(字符的序列)

  • python中单引号和双引号使用完全相同。
  • 使用三引号('''或""")可以指定一个多行字符串。
  • 转义符 '\'
  • 自然字符串, 通过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示,并不是换行。
  • python允许处理unicode字符串,加前缀u或U, 如 u"this is an unicode string"。
  • 字符串是不可变的。
  • 按字面意义级联字符串,如"this " "is " "string"会被自动转换为this is string。

  3. 标识符的命名

  • 第一个字符必须是字母表中字母或下划线'_'。
  • 标识符的其他的部分有字母、数字和下划线组成。
  • 标识符对大小写敏感。

  4. 对象

    python程序中用到的任何“东西”都成为“对象”。

  5. 逻辑行和物理行

    物理行是我们在编写程序时看到的,逻辑行则是python看到的。

    python中分号;标识一个逻辑行的结束,但是实际中一般每个物理行只写一个逻辑行,可以避免使用分号。

    多个物理行中可以写一个逻辑行,如下:

s = "peter is \
writing this article"

    上面\的使用被称为‘明确的行连接’, 又如:

print \

"peter"

  6. 缩进

    空白在python是非常重要的,行首的空白是最重要的,又称为缩进。行首的空白(空格和制表符)用来决定逻辑行的缩进层次,从而决定语句

  分组。这意味着同一层次的语句必须有相同的缩进,每一组这样的语句称为一个块。

  注意:不要混合使用空格和制表符来缩进,因为在跨越不同的平台时无法正常工作。

二、运算符与表达式

  1. 运算符与其用法

运算符 名称 说明 例子
+ 两个对象相加 3 + 5得到8。'a' + 'b'得到'ab'。
- 得到负数或是一个数减去另一个数 -5.2得到一个负数。50 - 24得到26。
* 两个数相乘或是返回一个被重复若干次的字符串 2 * 3得到6。'la' * 3得到'lalala'。
**

返回x的y次幂

3 ** 4得到81(即3 * 3 * 3 * 3)
/ x除以y 4/3得到1(整数的除法得到整数结果)。4.0/3或4/3.0得到1.3333333333333333
// 取整除 返回商的整数部分 4 // 3.0得到1.0
% 取模 返回除法的余数 8%3得到2。-25.5%2.25得到1.5
<< 左移 把一个数的比特向左移一定数目(每个数在内存中都表示为比特或二进制数字,即0和1) 2 << 2得到8。——2按比特表示为10
>> 右移 把一个数的比特向右移一定数目 11 >> 1得到5。——11按比特表示为1011,向右移动1比特后得到101,即十进制的5。
& 按位与 数的按位与 5 & 3得到1。
| 按位或 数的按位或 5 | 3得到7。
^ 按位异或 数的按位异或 5 ^ 3得到6
~ 按位翻转 x的按位翻转是-(x+1) ~5得到6。
<</td> 小于 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写。 5 < 3返回0(即False)而3 < 5返回1(即True)。比较可以被任意连接:3 < 5 < 7返回True。
> 大于 返回x是否大于y 5 > 3返回True。如果两个操作数都是数字,它们首先被转换为一个共同的类型。否则,它总是返回False。
<= 小于等于 返回x是否小于等于y x = 3; y = 6; x <= y返回True。
>= 大于等于 返回x是否大于等于y x = 4; y = 3; x >= y返回True。
== 等于 比较对象是否相等 x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!= 不等于 比较两个对象是否不相等 x = 2; y = 3; x != y返回True。
not 布尔“非” 如果x为True,返回False。如果x为False,它返回True。 x = True; not y返回False。
and 布尔“与” 如果x为False,x and y返回False,否则它返回y的计算值。 x = False; y = True; x and y,由于x是False,返回False。在这里,Python不会计算y,因为它知道这个表达式的值肯定是False(因为x是False)。这个现象称为短路计算。
or 布尔“或” 如果x是True,它返回True,否则它返回y的计算值。 x = True; y = False; x or y返回True。短路计算在这里也适用。

   2. 运算符优先级(从低到高)

运算符 描述
lambda Lambda表达式
or 布尔“或”
and 布尔“与”
not x 布尔“非”
in,not in 成员测试
is,is not 同一性测试
<,<=,>,>=,!=,== 比较
| 按位或
^ 按位异或
& 按位与
<<,>> 移位
+,- 加法与减法
*,/,% 乘法、除法与取余
+x,-x 正负号
~x 按位翻转
** 指数
x.attribute 属性参考
x[index] 下标
x[index:index] 寻址段
f(arguments...) 函数调用
(experession,...) 绑定或元组显示
[expression,...] 列表显示
{key:datum,...} 字典显示
'expression,...' 字符串转换

   3. python 控制台输出 使用print

print "abc"    #打印abc并换行
print "abc%s" % "d"    #打印abcd
print "abc%sef%s" % ("d", "g")    #打印abcdefg

三、控制流

  1. if 语句

复制代码
i = 10

n = int(raw_input("enter a number:"))



if n == i:

    print "equal"

elif n < i:

    print "lower"

else:

    print "higher"
复制代码

   2. while语句

while True:

    pass

else:

    pass

#else语句可选,当while为False时,else语句被执行。 pass是空语句。

  3. for 循环 for..in

for i in range(0, 5):

    print i

else:

    pass

# 打印0到4

  注:当for循环结束后执行else语句;

    range(a, b)返回一个序列,从a开始到b为止,但不包括b,range默认步长为1,可以指定步长,range(0,10,2);

  4. break语句

    终止循环语句,如果从for或while中终止,任何对应循环的else将执行。

  5. continue语句

    continue语句用来调过当前循环的剩余语句,然后继续下一轮循环。

四、函数

  函数通过def定义。def关键字后跟函数的标识符名称,然后跟一对圆括号,括号之内可以包含一些变量名,该行以冒号结尾;接下来是一块语句,即函数体。

def sumOf(a, b):

    return a + b

  1. 函数形参

    函数中的参数名称为‘形参’,调用函数时传递的值为‘实参’

  2. 局部变量

    在函数内定义的变量与函数外具有相同名称的其他变量没有任何关系,即变量名称对于函数来说是局部的。这称为变量的作用域。

    global语句, 为定义在函数外的变量赋值时使用global语句。

复制代码
def func():

    global x

    print "x is ", x

    x = 1



x = 3

func()

print x



#3

#1 
复制代码

  3. 默认参数

    通过使用默认参数可以使函数的一些参数是‘可选的’。

def say(msg, times =  1):

    print msg * times



say("peter")

say("peter", 3)

    注意:只有在形参表末尾的那些参数可以有默认参数值,即不能在声明函数形参的时候,先声明有默认值的形参而后声明没有默认值的形参,只是因为赋给形参的值是根据位置而赋值的。

  4. 关键参数

    如果某个函数有很多参数,而现在只想指定其中的部分,那么可以通过命名为这些参数赋值(称为‘关键参数’)。

    优点:不必担心参数的顺序,使函数变的更加简单;假设其他参数都有默认值,可以只给我们想要的那些参数赋值。

复制代码
def func(a, b=2, c=3):

    print "a is %s, b is %s, c is %s" % (a, b, c)



func(1) #a is 1, b is 2, c is 3
func(1, 5) #a is 1, b is 5, c is 3
func(1, c = 10) #a is 1, b is 2, c is 10
func(c = 20, a = 30) #a is 30, b is 2, c is 20
复制代码

  5. return 语句

    return语句用来从一个函数返回,即跳出函数。可从函数返回一个值。

    没有返回值的return语句等价于return None。None表示没有任何东西的特殊类型。

  6. DocStrings (文档字符串)

复制代码
def func():

    '''This is self-defined function



Do nothing'''

    pass



print func.__doc__



#This is self-defined function

#

#Do nothing
复制代码

五、模块

  模块就是一个包含了所有你定义的函数和变量的文件,模块必须以.py为扩展名。模块可以从其他程序中‘输入’(import)以便利用它的功能。

  在python程序中导入其他模块使用'import', 所导入的模块必须在sys.path所列的目录中,因为sys.path第一个字符串是空串''即当前目录,所以程序中可导入当前目录的模块。

   1. 字节编译的.pyc文件

    导入模块比较费时,python做了优化,以便导入模块更快些。一种方法是创建字节编译的文件,这些文件以.pyc为扩展名。

    pyc是一种二进制文件,是py文件经编译后产生的一种byte code,而且是跨平台的(平台无关)字节码,是有python虚拟机执行的,类似于

  java或.net虚拟机的概念。pyc的内容,是跟python的版本相关的,不同版本编译后的pyc文件是不同的。

  2. from .. import

    如果想直接使用其他模块的变量或其他,而不加'模块名+.'前缀,可以使用from .. import。

    例如想直接使用sys的argv,from sys import argv 或 from sys import *

  3. 模块的__name__

    每个模块都有一个名称,py文件对应模块名默认为py文件名,也可在py文件中为__name__赋值;如果是__name__,说明这个模块被用户

  单独运行。

  4. dir()函数

    dir(sys)返回sys模块的名称列表;如果不提供参数,即dir(),则返回当前模块中定义名称列表。

    del -> 删除一个变量/名称,del之后,该变量就不能再使用。

六、数据结构

  python有三种内建的数据结构:列表、元组和字典。

  1. 列表

    list是处理一组有序项目的数据结构,列表是可变的数据结构。列表的项目包含在方括号[]中,eg: [1, 2, 3], 空列表[]。判断列表中是否包含某项可以使用in, 比如 l = [1, 2, 3]; print 1 in l; #True;支持索引和切片操作;索引时若超出范围,则IndexError;使用函数len()查看长度;使用del可以删除列表中的项,eg: del l[0] # 如果超出范围,则IndexError

    list函数如下:

    append(value)  ---向列表尾添加项value

l = [1, 2, 2]

l.append(3) #[1, 2, 2, 3]

    count(value)  ---返回列表中值为value的项的个数

l = [1, 2, 2]

print l.count(2) # 2

    extend(list2)  ---向列表尾添加列表list2

l = [1, 2, 2]

l1 = [10, 20]

l.extend(l1)

print l   #[1, 2, 2, 10, 20]

    index(value, [start, [stop]])  ---返回列表中第一个出现的值为value的索引,如果没有,则异常 ValueError

l = [1, 2, 2]

a = 4

try:

    print l.index(a)

except ValueError, ve:

    print "there is no %d in list" % a

    insert(i, value)  ---向列表i位置插入项vlaue,如果没有i,则添加到列表尾部

复制代码
l = [1, 2, 2]



l.insert(1, 100)

print l #[1, 100, 2, 2]


l.insert(100, 1000)

print l #[1, 100, 2, 2, 1000]
复制代码

    pop([i])  ---返回i位置项,并从列表中删除;如果不提供参数,则删除最后一个项;如果提供,但是i超出索引范围,则异常IndexError

复制代码
l = [0, 1, 2, 3, 4, 5]



print l.pop() # 5
print l #[0, 1, 2, 3, 4]


print l.pop(1) #1
print l #[0, 2, 3, 4]


try:

    l.pop(100)

except IndexError, ie:

    print "index out of range"
复制代码

    remove(value)  ---删除列表中第一次出现的value,如果列表中没有vlaue,则异常ValueError

复制代码
l = [1, 2, 3, 1, 2, 3]



l.remove(2)

print l #[1, 3, 1, 2, 3]


try:

    l.remove(10)

except ValueError, ve:

    print "there is no 10 in list"
复制代码

    reverse()  ---列表反转

l = [1, 2, 3]

l.reverse()

print l #[3, 2, 1]

    sort(cmp=None, key=None, reverse=False)  ---列表排序

【Python Library Reference】
cmp:cmp specifies a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: 
"cmp=lambda x,y: cmp(x.lower(), y.lower())" 
key:key specifies a function of one argument that is used to extract a comparison key from each list element: "key=str.lower"
reverse:reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.In general, the key and reverse conversion processes are much faster than specifying an 
equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once.

复制代码
l5 = [10, 5, 20, 1, 30]

l5.sort()

print l5 #[1, 5, 10, 20, 30]


l6 = ["bcd", "abc", "cde", "bbb"]

l6.sort(cmp = lambda s1, s2: cmp(s1[0],s2[1]))

print l6 #['abc', 'bbb', 'bcd', 'cde']


l7 = ["bcd", "abc", "cde", "bbb", "faf"]

l7.sort(key = lambda s: s[1])

print l7 #['faf', 'abc', 'bbb', 'bcd', 'cde']
复制代码

 Python的设计目标之一是让源代码具备高度的可读性。它设计时尽量使用其它语言经常使用的标点符号和英语单词,让源代码整体看起来很整洁美观。它不像静态语言如C、Pascal那样需要重复书写声明语句,也不像它们的语法那样经常有特殊情况和惊喜。

缩进

Python开发者有意让违反了缩进规则的程序不能通过编译,以此来强制程序员养成良好的编程习惯。并且在Python语言里,缩进而非花括号或者某种关键字,被用于表示语句块的开始和退出。增加缩进表示语句块的开始,而减少缩进则表示语句块的退出。缩进成为了语法的一部分。例如

if语句:

 

if age <</span> 21:
print("你不能買酒。")
print("不過你能買口香糖。")
print("這句話處於if語句塊的外面。")

根据PEP的规定,必须使用4个空格来表示每级缩进。使用Tab字符和其它数目的空格虽然都可以编译通过,但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为了兼容很旧的Python程序和某些有问题的编辑器。

语句和控制流

  • if语句,当条件成立时执行语句块。经常与else,elif(相当于else if)配合使用。
  • for语句,遍历列表、字符串、字典、集合等迭代器,依次处理迭代器中的每个元素。
  • while语句,当条件为真时,循环执行语句块。
  • try语句。与except,finally配合使用处理在程序运行中出现的异常情况。
  • class语句。用于定义类型。
  • def语句。用于定义函数和类型的方法。
  • pass语句。表示此行为空,不执行任何操作。
  • assert语句。用于程序调试阶段时测试运行条件是否满足。
  • with语句。Python2.6以后定义的语法,在一个场景中运行语句块。比如,运行语句块前加锁,然后在语句块运行结束后释放它。
  • yield语句。在迭代器函数内使用,用于返回一个元素。自从Python 2.5版本以后。这个语句变成一个运算符。

表达式

Python的表达式写法与C/C++类似。只是在某些写法有所差别。

  • 主要的算术运算符与C/C++类似。+, -, *, /, //, **, ~, %分别表示加法或者取正、减法或者取负、乘法、除法、整除、乘方、取补、取模。>>, <<表示右移和左移。&, |, ^表示二进制的AND, OR, XOR运算。>, <, ==, !=, <=, >=用于比较两个表达式的值,分别表示大于、小于、等于、不等于、小于等于、大于等于。在这些运算符里面,~, |, ^, &, <<, >>必须应用于整数。
  • Python使用andornot表示逻辑运算。
  • is, is not用于比较两个变量是否是同一个对象。in, not in用于判断一个对象是否属于另外一个对象。
  • 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的元素,但不包含下标为2的元素。
  • 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]

函数

Python的函数支持递归、默认参数值、可变参数,但不支持函数重载。为了增强代码的可读性,可以在函数后书写”文档字符串“(Documentation Strings,或者简称docstrings),用于解释函数的作用、参数的类型与意义、返回值类型与取值范围等。可以使用内置函数help()打印出函数的使用帮助。比如:

复制代码
1 >>> def randint(a, b):
2 ... "Return random integer in range [a, b], including both end points."
3 ...
4 >>> help(randint)
5 Help on function randint in module __main__:
6
7 randint(a, b)
8 Return random integer in range [a, b], including both end points.
复制代码

对象的方法

对象的方法是指绑定到对象的函数。调用对象方法的语法是instance.method(arguments)。它等价于调用Class.method(instance, arguments)。当定义对象方法时,必须显式地定义第一个参数为self,用于访问对象的内部数据。self相当于C++, Java里面的this变量。比如:

复制代码
class Fish:
def eat(self, food):
if food is not None:
self.hungry
=False

#构造Fish的实例:
f=Fish()
#以下两种调用形式是等价的:
Fish.eat(f, "earthworm")
f.eat(
"earthworm")
复制代码

Python认识一些以”__“开始并以"__"结束的特殊方法名,它们用于实现运算符重载和实现多种特殊功能。

类型

Python采用动态类型系统。在编译的时候,Python不会检查对象是否拥有被调用的方法或者属性,而是直至运行时,才做出检查。所以操作对象时可能会抛出异常。不过,虽然Python采用动态类型系统,它同时也是强类型的。Python禁止没有明确定义的操作,比如数字加字符串。

与其它面向对象语言一样,Python允许程序员定义类型。构造一个对象只需要像函数一样调用类型即可,比如,对于前面定义的Fish类型,使用Fish()。类型本身也是特殊类型type的对象(type类型本身也是type对象),这种特殊的设计允许对类型进行反射编程。

Python内置丰富的数据类型。与Java、C++相比,这些数据类型有效地减少代码的长度。下面这个列表简要地描述了Python内置数据类型(适用于Python 3.x):

类型 描述 例子
str 一个由字符组成的不可更改的有串行。在Python 3.x里,字符串由Unicode字符组成。 'Wikipedia'
"Wikipedia"
"""Spanning
multiple
lines"""
bytes 一个由字节组成的不可更改的有串行。 b'Some ASCII'
b"Some ASCII"
list 可以包含多种类型的可改变的有串行 [4.0, 'string', True]
tuple 可以包含多种类型的不可改变的有串行 (4.0, 'string', True)
set, frozenset 与数学中集合的概念类似。无序的、每个元素唯一。 {4.0, 'string', True}
frozenset([4.0, 'string', True])
dict 一个可改变的由键值对组成的无串行。 {'key1': 1.0, 3: False}
int 精度不限的整数 42
float 浮点数。精度与系统相关。 3.1415927
complex 复数 3+2.7j
bool 逻辑值。只有两个值:真、假 True
False

除了各种数据类型,Python语言还用类型来表示函数、模块、类型本身、对象的方法、编译后的Python代码、运行时信息等等。因此,Python具备很强的动态性。

数学运算

Python使用与C、Java类似的运算符,支持整数与浮点数的数学运算。同时还支持复数运算与无穷位数(实际受限于计算机的能力)的整数运算。除了求绝对值函数abs()外,大多数数学函数处于mathcmath模块内。前者用于实数运算,而后者用于复数运算。使用时需要先导入它们,比如:

>>> import math
>>> print(math.sin(math.pi/2))
1.0

fractions模块用于支持分数运算;decimal模块用于支持高精度的浮点数运算。

Python定义求余运行% b的值处于开区间[0, b)内,如果b是负数,开区间变为(b, 0]。这是一个很常见的定义方式。不过其实它依赖于整除的定义。为了让方程式:b * (a // b) + a % b = a恒真,整除运行需要向负无穷小方向取值。比如7 // 3的结果是2,而(-7) // 3的结果却是-3。这个算法与其它很多编程语言不一样,需要注意,它们的整除运算会向0的方向取值。

Python允许像数学的常用写法那样连着写两个比较运行符。比如a < b < ca < b and b < c等价。C++的结果与Python不一样,首先它会先计算a < b,根据两者的大小获得0或者1两个值之一,然后再与c进行比较。

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:1046194次
    • 积分:18267
    • 等级:
    • 排名:第521名
    • 原创:741篇
    • 转载:523篇
    • 译文:0篇
    • 评论:105条
    最新评论