python 语法学习小结

基础

1. 当语句以冒号:结尾时，缩进的语句视为代码块。使用4个空格的缩进。
2. Python程序是大小写敏感的，如果写错了大小写，程序会报错。
3. Python使用缩进来组织代码块，请务必遵守约定俗成的习惯，坚持使用4个空格的缩进。
4. 十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
5. 字符串是以单引号’或双引号”括起来的任意文本，

6. 转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串

   如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r”表示”内部的字符串默认不转义，

   如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用”’…”’的格式表示多行内容

   print('''line1
   line2
   line3''')

7. 在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算(就是比较对比操作)计算出来：

   and运算 是 与 运算
   or运算 是 或 运算
   not运算 是 非 运算

8. 空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

9. 在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。

   这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言。与静态语言相比，动态语言更灵活

   理解变量在计算机内存中的表示也非常重要。当我们写：

   a = 'ABC'

   时，Python解释器干了两件事情：

   • 在内存中创建了一个'ABC'的字符串；
   • 在内存中创建了一个名为a的变量，并把它指向'ABC'。

   也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，

10. 在Python中，有两种除法，一种除法是/ 计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数。

    还有一种除法是//，称为地板除,整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。

    因为//除法只取结果的整数部分，所以Python还提供一个余数运算%，可以得到两个整数相除的余数。无论整数做//除法还是%取余数，结果永远是整数，所以，整数运算结果永远是精确的。

self

1. self代表类的实例，而非类,类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

2. 首先明确的是self只有在类的方法中才会有，独立的函数或方法是不必带有self的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数

class Test:
    def prt(self):
        print(self)
        print(self.__class__)

t = Test()
t.prt()

python的字符串

字符串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

如果你要实现从字符串中获取一段子字符串的话，可以使用变量 [头下标:尾下标]，就可以截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

str = 'Hello World!'
print str           # 输出完整字符串
print str[0]        # 输出字符串中的第一个字符
print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
print str[2:]       # 输出从第三个字符开始的字符串
print str * 2       # 输出字符串两次
print str + "TEST"  # 输出连接的字符串

print str[-1]  # 从右向左输出一个字符
print str[-5:]  # 从右向左第五个字符处输出到结尾
print str[-5:-2]  #从倒数第五个字符输出到倒数第二个字符

字符串编码

1. 对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

   65
   >>> ord('中')
   20013
   >>> chr(66)
   'B'
   >>> chr(25991)
   '文'

   还可以用十六进制这么写str：

   >>> '\u4e2d\u6587'
   '中文'

2. 由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

   
   #!/usr/bin/env python3
   
   
   # -*- coding: utf-8 -*-
   

   第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

   第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

3. %运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

   常见的占位符有：

   %d  整数
   %f  浮点数
   %s  字符串
   %x  十六进制整数

集合

1. list是Python内置的一种有序的集合，可以随时添加和删除其中的元素。(元素没有数据类型限制)

   用len()函数可以获得list元素的个数

   除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素

#!/usr/bin/env python3
# -*- coding: utf-8 -*-


list=['abel',234,'bo','hui','yi','xiao']
print(len(list)) #取出list的长度
print(list[0])  #取出第一个元素
print(list[1:3]) #取出第二和第三个元素  (包头不包尾)
print(list[-1]) #取出倒数第一个元素
print(list[-2:]) ##取出倒数第二个元素
print(list[-3:-1])##取出倒数第第三和第二个元素  (包头不包尾)
# print(list(4))  #数组越界
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: list index out of range

Python元组

元组是另一个数据类型，类似于List（列表,语法相似）。
元组用”()”标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

元组是不允许更新的。而列表是允许更新的

tuple=(123,'yang','bo',1098,34,'an')
print(tuple[3:])
print(tuple[-2])

tuple[2]='an'  //元组是不允许更新的。而列表是允许更新的。报错TypeError: 'tuple' object does not support item assignment

字典 类似 java 的 map

字典是无序的对象集合。
字典当中的元素是通过键来存取的，而不是通过偏移存取。

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()      # 输出所有键 按照a－z 顺序
print tinydict.values()    # 输出所有值

运算符

运算符	描述	实例
/	除 - x除以y	b / a 输出结果 2
**	幂 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
& (与)	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(0011 1100 & 0000 1101) 输出结果 12 ，二进制解释： 0000 1100
`	`(或)	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
^ (非)	按位异或运算符：当两对应的二进位相异时，结果为1	(0011 1100 ^ 0000 1101) 输出结果 49 ，二进制解释： 0011 0001
~ (取反)	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1	(~0011 1100 ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0。	0011 1100 << 2 输出结果 240 ，二进制解释： 1111 0000
>	右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，	“>>”右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注意：Python2.x 里，整数除整数，只能得出整数。如果要得到小数部分，把其中一个数改成浮点数即可。

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

a=10
b=5

print(a/float(b))

循环

Python提供了for循环和while循环（在Python中没有do..while循环）:

循环控制语句

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

控制语句	描述
break 语句	在语句块执行过程中终止循环，并且跳出整个循环
continue 语句	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句	pass是空语句，是为了保持程序结构的完整性。

在 python 中，while … else 在循环条件为 false 时执行 else 语句块：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
numbers=['mac','an','yang','xiao','hui','bo']
event=[]
odd=[]
while len(numbers)> 0 :
    number=numbers.pop()
    if len(numbers) == 1:
        break
    else:
        if 'a' in number:
            event.append(number)
        else:
            odd.append(number)
else:
    print("while is fail")    
print(event)
print(odd)

for循环

for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print '当前水果 :', fruit
else:
    print '洋水果' 

函数

• 数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
  任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
• 函数要声明在调用之前

语法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

示例

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print "函数内 : ", total
   return total;
print(str(sum(10,5)));

如果要给函数内的全局变量赋值，必须使用 global 语句。

Money = 2000
def AddMoney():
   # 想改正代码就取消以下注释:
   global Money
   Money = Money + 1

print Money
AddMoney()
print Money

globals() 和 locals() 函数

• 根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
• 如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
• 如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
• 两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

操作文件

open 函数

你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
相关方法：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

示例：

fo = open("foo.txt", "wb")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(‘\n’)：

 file.write("此情永流转，千载永不渝!")

read()方法

read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：

fileObject.read([count]);

在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。

注意：创建文件或改名字，修改文件需要 import os 不能忘记

#文件操作小李子
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def tellFile(file):
    position = file.tell();
    print ("当前文件位置 : "+ str(position))

def seekFile(file):
    position = fo.seek(0,0);
    print "从开头开始读取: ";
    readFile(file);

def readFile(file):
    print(file.read(100))


def writeFile(file):
    file.write("此情永流转，千载永不渝!")


def closeFile(file):
    file.close();

def renameFile(oldName,newName):
    os.rename(oldName,newName);
    return newName;

import os

try:
    fo = open("testFile.txt","rb+")
    print "文件名: ", fo.name
    print "是否已关闭 : ", fo.closed
    print "访问模式 : ", fo.mode
    print "末尾是否强制加空格 : ", fo.softspace
    tellFile(fo);
    writeFile(fo);
    seekFile(fo);     
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    closeFile(fo);

print os.getcwd() #显示当前的工作目录
# renameFile("testFile.txt","testFile.log")
os.mkdir("ML")
# os.rmdir('newdir') #删除目录,在删除这个目录之前，它的所有内容应该先被清除。
# os.remove("testFile.txt");

本文源码：https://github.com/527515025/pythonLean