Python笔记（1）--基础语法

June 12th, 2017 original post at hetaodie.github.io

目录

基础知识

基础语法

基本语法总汇

新建脚本文件时需要在文件的头部进行如下声明：

多行语句

  • 说明：python语句中一般以行作为语句的结束符，但是我们可以使用斜杠（\）将一行的语句分为多行显示，如下所示：
total = item_one + \
		 item_twe + \
		 item_three

语句中包含{}，[]或（）就不需要使用多行连接符。

Python引号 Python 使用单引号（’），双引号（”）,三引号（’’’ “”“）来表示字符串，引号的开始与结束必须是相同的类型。其中三引号可以由多行组成。

  • python中单行注释采用#开头
  • python中多行注释使用三个单引号或是三个多引号。

数据类型

  1. python 支持五个标准数据类型：
    • Numbers(数字)
    • String(字符串)
    • List(列表)
    • Tuple(元组)
    • Dictionary
  2. python支持四种不同的数据类型：
  • int(有符号)

  1. 数学操作符

    • ** ：指数：2**3 = 8
    • %：取模/取余数 22%8 = 6
    • //: 取整 22//8 = 2
    • / : 除法 22/8 = 2.75
    • *: 乘法
    • ’-‘:减法
    • ’+’:加法
# ！/usr/bin/python

**当有中文时，应加入**

# -*- coding: UTF-8 -*-

基本操作

  1. 常用操作符
  2. 通过+可以连接两个字符串
  3. ‘’表示乘法，但“”操作符用于一个字符串和一个整数时，它变成了“字符串复制”操作符。他将原来的字符串复制若干次，次数就是整型的值。
‘weixu’* 3
其结果为：
 ‘weixuweixuweixu’

  1. python的变量名是区分大小写的

  2. 字符转换为整形 int(“char”)

  3. 其他转换为string类型：str(int(“字符”))

  4. 变量名是区分大小写的

  5. 常用函数

    • print()函数：输出

    • input()函数：输入

    • len()函数：获得字符串长度

      ​

控制流

  1. 布尔数据类型只有两种值：True和False。首字母必须大写。
  2. not操作符只作用于一个布尔值（或表达式）。not操作符求值为相反的布尔值。
  3. 通过代码行的缩进来控制代码块的开始和结束。
  4. 代码块有3条规则：
    1. 缩进增加时，代码块开始；
    2. 代码块可以包含其他代码块；
    3. 缩进减少为零，或减少为外面包围代码块的缩进，代码块结束
  5. 条件语句：
    1. if语句包含以下部分：
      1. if 关键字
      2. 条件
      3. 冒号（:）
      4. 在下一行开始，缩进的代码块
    2. elif语句包含以下部分
      1. elif关键字
      2. 条件
      3. 冒号（:）
      4. 在下一行开始，缩进的代码块
    3. else语句包含以下部分：
      1. else关键字
      2. 冒号
      3. 在下一行开始，缩进的代码块
if name == 'weixu':
    print('hi, weixu')
elif age < 12:
    print('You are not weixu ')
else:
    print('You are not weixu, and >=12')
  1. while 循环语句：
    1. 格式while 条件 冒号（:）
    2. while循环中的break语句用来跳出循环
    3. while循环中的continue用来调整本次循环，进入下一个循环
​	
	while True:
		print('Who are you?')
		name = input()
		if name != 'Joe':
			continue
		print('hello, Joe. What is the password? (It is a fish.)')
		password = input()
		if password == 'swordfish':
			break
	print('Access granted.')
  1. for循环语句包含以下部分
    1. for关键字
    2. 一个变量名
    3. in关键字
    4. 调用range()方法，最多传入3个参数
    5. 冒号(:)
    6. 从下一行开始，缩退的代码块
  2. range()函数开始、停止和步长参数

  3. 三个参数用逗号(,)分割

  4. 第一个参数省略表示用0开始

  5. 第三个参数省略表示步长为1

  6. 可是使用负数为步长，让循环计数逐渐减少

    ​

for i in range(5, -1, -1):
	print(i)

导入模块

在开始使用一个模块中的函数之前，必须使用import语句导入该模块 import语句包含以下部分：

  1. import 关键字
  2. 模块的名称
  3. 可选的更多的模块名称，之间用逗号(,)隔开
import random, sys

用sys.exit()提前结束程序

函数

定义

def hello(name)
	return

说明：

  1. 使用def定义函数，def 后面跟函数名称
  2. 函数名括号内为函数参数
  3. 使用return 作为返回值
  4. global 语句：如果需要在一个函数内修改全局变量，就使用global语句
def spam()：
	global eggs
    eggs = 'spam'
eggs = 'global'
spam()
print(eggs)

  1. 异常处理 try excepty

     try:
        i = i/i
 except ZeroDivisionError:
    print('error')

列表

定义

  1. 列表是一个值，它包含多个字构成的序列。

  2. 用下标取得列表中的单个值，

  3. 如果使用下标超出了列表中值的个数，python将给出IndexError出错信息

  4. 负数下标：整数值-1指的是列表中的最后一个下标，-2 是列表中倒数第二个下标

  5. 利用切片获得子列表

    • spam[2]：是一个列表和下标
    • spam[1:4]:是一个列表和切片，在一个切片中，第一个整数是切片开始处的下标，第二个整数是切片结束处的下标，切片向上增长，直至第二个下标，但不包括它

  6. 使用len获得列表的长度,返回列表中值的个数

  7. 使用下标改变列表中的值

  8. 使用+操作符连接两个列表

  9. 使用del语句从列表中删除值：del语句将删除列表中下标处的值

  10. 使用in 和not in 操作符，可以确定一个值是否在列表中

    spam = ['cat', 'bat', 'rat', 'elephant']

#切片获得子列表
spam[1:4]

#获得列表的个数
len(spam)

#改变列表的值
spam[0] = 'aba'

#连接两个列表

ani = ['cay', 'wo']
spam = spam + ani

#添加列表demo
catNames = []
while True:
    name = input()
    if name == '':
        break
    catNames = catNames + [name] #list concatenation
        
# 多重赋值:变量长度和列表的长度必须严格相等
cat = ['fat', 'black', 'loud']
size, color, disposition = cat

常用方法

  1. 用index()方法在列表中查找值：可以传入一个值，如果该值存在于列表中，就返回它的下标，如果该值不在列表中，Python就报ValueError。
  2. 使用append()和insert()方法在列表中添加值：调用append方法，将参数添加到列表尾部，insert方法可以在列表中任意下标中插入一个值，insert方法的第一个参数是新值的下标，第二个参数是要插入的值。
  3. 使用remove()方法从列表中删除值：给remove()方法传入一个值，它将从被调用的列表中删除；如果试图删除列表中不存在的值，将导致ValueError错误，如果该值在列表中出现多次，只有第一次出现的值会被删除。
  4. 用sort()方法将列表中的值排序：也可以指定reverse关键字参数为True让sort()按逆序排序。
apam = ['cat', 'dog', 'bat']
spam.insert(1, 'chicken')
spam.append('moose') 
spam.remove('cat') #删除cat

sort()方法注意事项：

  • sort() 没有返回值，直接排序使用
  • 不能对既有数字又有字符串的列表进行排序
  • sort()方法对字符串排序时，使用‘ASCII字符顺序’，而不是实际的字典顺序。如果需要使用字典顺序，则设置关键字参数key 设置为str.lower
spam.sort()
spam.sort(reverse=True) #逆序排序
apam = ['a', 'z', 'A', 'Z']
spam.sort()
spam.sort(key=str.lower) #使用字典顺序排序

元组

  1. 元组用圆括号()表示
  2. 元组像字符串一样，是不可变的
  3. 如果元组中只有一个值，后面要跟上一个逗号
  4. 使用tuple()函数可以把列表装换成元组，使用list()函数可以把元组转换成列表
tuple(['cat', 'dog', 5])
list(('cat', 'dog', 5))

引用

  1. 列表使用的是引用方式
  2. 列变作为函数的参数也是引用的方式
  3. 如果不想使用引用，就使用copy模块提供的copy()和deepcopy()函数

字典

  1. 字典使用大括号

  2. 字典的键值可以是字符也可以是数字

  3. 尝试访问字典中不存在的键，将导致 KeyError 出错信息，可以使用关键字in来判断key是否是字典的键值。

  4. 字典有3个方法，分别是keys(),values(), items()。分别对应于字典的键、值和键值对。这些方法返回的值不是真正的列表，它们不能被修改。注意：items 返回的是一个包含键和值的元组。

  5. 使用字典的get()方法，他有两个参数：要取的其值的键，以及如果改键不存在时，返回的备用值。

  6. setdefault() 方法提供了一种方式，在一行中完成这件事。传递给该方法的第一个参数，是要检查的键。第二个参数，是如果该键不存在时要设置的值。如果该键确实存在，方法就会返回键的值。

    ​

    picnicItems = {'apples':5, 'cups':2}
picnicItems.get('cups',0)

    ​

    ​

字符串

  1. 字符串可以使用双引号开始和结束，就像用单引号一样。使用双引号的一个好处，就是字符中可以使用单引号字符。

  2. 转义字符（\）

  3. 原始字符串：可以在字符串开始的引号之前加上r，使它成为原始字符串。“原始字符串”完全忽略所有的转义字符，打印出字符串中所有的倒斜杠。

  4. 用三重引号实现多行字符串：多行字符串的起止是3个单引号或3个双引号。三重引号 之间的所有引号、制表符或换行，都被认为是字符串的一部分。

  5. ‘#’ 号实现一行注释，“”“ 多行注释 ”“”

  6. 字符串的in和not in操作符：用来判断字符串是否在另一个字符串中。

  7. upper(), lower()：字符串方法返回一个新的字符串，其中原字符串的所有字母都被相应地转换为大写或是小写。字符串中非字母字符保持不变。

  8. isupper() 和 islower()方法：字符串中至少有一个字母，并且所有字母都是大写或小写。isupper()和islower()方法就会相应地返回布尔值True。

    ​

isalpha()返回 True，如果字符串只包含字母，并且非空;
isalnum()返回 True，如果字符串只包含字母和数字，并且非空;
isdecimal()返回 True，如果字符串只包含数字字符，并且非空;
isspace()返回 True，如果字符串只包含空格、制表符和换行，并且非空;
istitle()返回 True，如果字符串仅包含以大写字母开头、后面都是小写字母的单词
  1. startswith()和endswith():如果他们所调用的字符串是以该方法传入的字符串开始或是结束。就返回True。否则返回False。
  2. join()函数：将一个字符串列表连接起来。参数是一个字符串列表。用调用的字符串分割。
  3. split()函数：使用函数的参数对字符串进行分割，并返回字符串列表
span = ','.join(['cats', 'rats', 'bats'])
"cats, rats, bats"
list = span.split(',')
['cats', 'rats', 'bats']
  1. rjust() 和ljust()：右对齐和左对齐。这两个方法的第一个参数是一个整数长度，第二个参数是指定一个填充字符，默认是空格。
  2. center()是让文本居中。
'Hello'.rjust(10) #将'Hello'放在一个长度为 10 的字符串中。 'Hello'有 5 个字符，所以左边会加上 5 个空格，得到一个 10 个字符的字符串，实现 'Hello'右对齐

  1. 用strip()、rstrip()和 lstrip()分别为删除左边和右边的空白字符、删除右边空白字符、删除左边字符。

  2. 使用pyperclip模块拷贝粘贴字符串：通过其函数copy()和paste()函数，可以向计算机的剪贴板发送文本，或是从它接收文本。

  3. pyperclip 模块不是 Python 自带的。要安装它。

    ​

正则表达式

正则表达式简称‘regex’，如果在python中需要使用正则表达式需要导入re模块。

向re.compile()传入一个字符串，表示正则表达式，它将返回一个regex模式对象。regex对象的search()方法查找传入的字符串，寻找该正则表达式的所有匹配。如果字符串中没有找到该正则表达式，search()方法将返回none。如果找到了该模式，search方法将返回一个match对象。match对象有一个group()方法，它返回被查找字符串中实际匹配的文本。

phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')
mo = phoneNumRegex.search('my number is 415-555-4242')
print('Phone number found: ' + mo.group())
打印出来：415-555-4242

利用括号分组

​ 假如想将区号从电话号码中分离。添加括号将在正则表达式中创建’分组’ (\d\d\d)-(\d\d\d-\d\d\d\d) 。然后可以使用group()匹配对象方法，从一个分组中获取匹配的文本。

​ 正则表达式字符串中的第一对括号是第1组。第二对括号是第2组。向group()匹配对象方法传入整数1或2，就可以得到匹配文本的不同部分。向group()方法传入0或是不传入参数，将返回整个匹配的文本。

​ 如果想获得所有的分组，请使用groups()方法。

phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
mo = phoneNumRegex.search('my number is 415-555-4242')
mo.group(1)
'415'
mo.group(2)
'555-4242'
mo.group(0)
'415-555-4242'
mo.group()
'415-555-4242'

mo.groups()
('415','555-4242')
areaCode, mainNumber = mo.groups()
print(areaCode)
415
print(mainNumber)
555-4242

括号在正则表达式中有特殊的含义，但是如果你需要在文本中匹配括号，就需要用倒斜杠对进行字符转义。

用管道匹配多个分组

​ 字符** **称为”管道“。希望匹配许多表达式中的一个时。就可以使用它。将找到第一次出现的匹配文本。

​ 可以利用findall()方法，找到”所有“匹配的地方。

基本语法

  1. ‘\d’：表示一位数字

  2. 用问号？实现可选匹配：字符？表明它前面的分组在这个模式中是可选择的

    batRegex = re.compile(r'Bat(wo)?man')
mo1 = batRegex.search('The Adventures of Batman') >>> mo1.group()
'Batman'
mo2 = batRegex.search('The Adventures of Batwoman') >>> mo2.group()
'Batwoman'

  3. 用星号匹配零次或多次：* 意味着”匹配零次或多次“，及星号之前的分组，可以在文本中出现任意次。它可以完全不存在，或一次又一次的重复。

>>> batRegex = re.compile(r'Bat(wo)*man')
>>> mo1 = batRegex.search('The Adventuresof Batman') 
>>> mo1.group()
'Batman'
>>> mo2 = batRegex.search('The Adventures of Batwoman') 
>>> mo2.group()
'Batwoman'
>>> mo3 = batRegex.search('The Adventures of Batwowowowoman')
>>> mo3.group()
'Batwowowowoman'
  1. 用加号匹配一次或多次：加号前面的分组必须”至少出现一次“。
  2. 用花括号匹配特定的次数:(Ha){3}:匹配HaHaHa，(Ha){3,5}：指定范围为一个最小值一个最大值，将匹配重复3次、4次、5次的。

贪心和非贪心匹配

Python的正则表达式默认是”贪心“的，这表示在有二义的情况下，它们会尽可能匹配最长的字符串。花括号的”非贪心”版本匹配尽可能最短的字符串，及在结束的花括号后跟着一个问号。

>>> greedyHaRegex = re.compile(r'(Ha){3,5}') >>> mo1 = greedyHaRegex.search('HaHaHaHaHa') >>> mo1.group()
'HaHaHaHaHa'
>>> nongreedyHaRegex = re.compile(r'(Ha){3,5}?') >>> mo2 = nongreedyHaRegex.search('HaHaHaHaHa') >>> mo2.group()
'HaHaHa'

findall方法

如果正则表达式中没有分组，findall返回一个字符串列表。如果正则表达式中有分组，findall将返回元组列表

# 无分组
>>> phoneNumRegex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups >>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000') ['415-555-9999', '212-555-0000']

# 有分组
>>> phoneNumRegex = re.compile(r'(\d\d\d)-(\d\d\d)-(\d\d\d\d)') # has groups >>> phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')
[('415', '555', '1122'), ('212', '555', '0000')]

字符分类

  • \d :0到9的任何数字
  • \D:除0到9的数字以外的任何字符
  • \w:任何字母、数字或下划线（可以认为是匹配”单词“字符）
  • \s:空格、制表符或换行符（可以认为是匹配”空白“字符）
  • \S:除空格制表符和换行符以外的任何字符

建立自己的字符分类

使用方括号建立自己的字符分类，可以使用方括号定义自己的字符分类。例如，字符分类[aeiouAEIOU]将匹配所有的元音字符，不论大小写。也可以使用短横表示字母或数字的范围。例如：[a-zA-Z0-9]将匹配所有小写字母、大写字母和数字。在方括号内，普通的正则表达式符号不会被解释。

​ 通过在字符分类的左边括号后加上一个插入字符（^），就可以得到“非字符类”。非字符类将匹配不在这个字符类中的所有字符。

插入字符和美元字符

  1. 可以在正则表达式的开始处使用插入符号(^),表明匹配必须发生在被查找文本开始处。

  2. 可以在正则表达式的末尾加上美元符号（$）,表示该字符串必须以这个正则表达式的模式结束.

    r'^Hello' # 匹配以‘Hello’ 开始的字符串。
r'\d$'  #匹配以数字0到9结束的字符串
r'^\d+$' #匹配从开始到结束都是数字的字符串

通配符

在正则表达式中，.(句点)字符称为“通配符”。它匹配除了换行之外的所有字符。

注意：句点字符只匹配一个字符。

用点星（.*）匹配所有的字符

点-星使用“贪心”模式：它总是匹配尽可能多的文本。要用“非贪心“模式匹配所有文本，就使用点-星和问号。(r'.*?')

用句点字符匹配换行

点-星将匹配除换行外的所有字符。通过传入re.DOTALL 作为 re.compile()的第二个参数，可以让句点字符匹配所有字符，包括换行字符。

newlineRegex = re.compile('.*', re.DOTALL)

正则表达式符号复习

  • ?匹配零次或一次前面的分组。
  • *匹配零次或多次前面的分组。
  • +匹配一次或多次前面的分组。
  • {n}匹配 n 次前面的分组。
  • {n,}匹配 n 次或更多前面的分组。
  • {,m}匹配零次到 m 次前面的分组。
  • {n,m}匹配至少 n 次、至多 m 次前面的分组。
  • {n,m}?或*?或+?对前面的分组进行非贪心匹配。
  • ^spam 意味着字符串必须以 spam 开始。
  • spam$意味着字符串必须以 spam 结束。
  • .匹配所有字符，换行符除外。
  • \d、\w 和\s 分别匹配数字、单词和空格。
  • \D、\W 和\S 分别匹配出数字、单词和空格外的所有字符。
  • [abc]匹配方括号内的任意字符(诸如 a、b 或 c)。
  • [^abc]匹配不在方括号内的任意字符。

不区分大小写的匹配

​ 通常，正则表达式用你指定的大小写匹配文本。可以通过向re.compile()传入re.IGNORECASE 或 re.I，作为第二个参数。

>>> robocop = re.compile(r'robocop', re.I)
>>> robocop.search('RoboCop is part man, part machine, all cop.').group() 
>>>'RoboCop'
>>> robocop.search('ROBOCOP protects the innocent.').group() >>>ROBOCOP'
>>> robocop.search('Al, why does your programming book talk about robocop so much?').group() 
>>>'robocop'

用sub()方法替换字符串

​ 可以使用sub()方法替换字符串，regex对象的sub()方法需要传入两个参数。第一个参数是一个字符串，用于取代发现的匹配。第二个参数是一个字符串，即正则表达式。sub()方法返回替换完成后的字符串。

>>> namesRegex = re.compile(r'Agent \w+')
>>> namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.') 'CENSORED gave the secret documents to CENSORED.'

​ 有时候，你可能需要使用匹配的文本本身，作为替换的一部分。在sub()的第一个参数中，可以输入\1、\2、\3…..。表示”在替换中输入分组1、2、3“的文本。

​ 例如：假如想要隐去密探的姓名，只显示他们姓名的第一个字母。要做到这一点，可以使用正则表达式Agent(\w)\w*,传入r’\1’作为sub()的第一个参数。字符串中的\1将有分组1匹配的文本所代替，也就是正则表达式的（\w）分组。

>>> agentNamesRegex = re.compile(r'Agent (\w)\w*')
>>> agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
A**** told C**** that E**** knew B**** was a double agent.'

管理复杂的正则表达式

通过向re.compile()传入变量re.VERBOSE，作为第二个参数。用来忽略正则表达式字符串中的空白符合注释。

组合使用re.IGNORECASE re.DOTALL 和re.VERBOSE

​ 如果你希望在正则表达式中使用re.verbose 来编写注释，还希望使用re.ignorecase 来忽略大小写，可以使用管道字符（ ）将变量组合起来。

常用函数汇总

  1. print()函数将括号内的字符串显示在屏幕上。
  2. input()函数等待用户在键盘上输入一些文本，并按下回车键
  3. len()函数传递一个字符串，然后使用该函数获得该字符的个数
  4. str()函数可以传入一个整型值，并求值为它的字符串形式
  5. int()函数把传入的字符串转换为整型
  6. float()函数把传入的字符串转换为浮点数的形式

如果觉得我的文章对您有用，请随意打赏。您的支持将鼓励我继续创作！

hetaodie

Mobile development

简单，深入的研究移动客户端开发技术"