Python基础语法

Python

1.基础语法系列

查看变量内存地址

a=456
id(a)

output： 2230777619920

lambda函数支持输入多个对象

判断语句

判断是否相等

利用==判断是否相等

x=[1,3,5,7,6]
y=x[:]
id(x)==id(y)

output:  False

利用is判断是否相同

a=[1,2,3,4,5]
b=a
a is b

output: True
    
a=[1,2,3,4,5]
b=[1,2,3,4,5]
a is b

output:  False

利用is not判断是否不同

a=[1,2,3,4,5]
b=a
a is not b

output: False

判断列表中是否存在对应元素

[1] in [[1], 2, 3, 4]
	     
output： True

[1] in [1, 2, 3, 4]

output:	 False

判断是否是字母

'abc10'.isalpha()

output:  False

判断是否是字母或者数字

'abc10'.isalnum()

output:  True

判断是否是数字

'abc10'.isdigit()

output:  False

判断是否以指定字母开头

'Beautiful is better than ugly.'.startswith('Be', 5)

output:  False

此代码中5表示从第六位开始是否以Be开头，若是返回True

判断是否以指定字符串结尾

'abc.txt'.endswith(('.txt', '.doc', '.jpg'))

output:  True

若有以上’.txt’、’.doc’、’.jpg’结尾的都返回True

判断是否…

利用if条件语句

字典

添加

x = {1:1}
x[3]=2
x

output:  {1:1,3:2}

查找

以key找value

• get方法

  #get(3,4) 3是用到的key,若字典中无此key,则返回4			#get(3,4) 3是用到的key,若字典中存在此key,则返回相应的value
  x = {1:2, 2:3}										 x = {1:2, 2:3}		
  x.get(3, 4)											 x.get(2, 4)
  
  output:  4											 output:  3
  

将两个列表合并为字典

key和value数一样

a = ['name', 'age', 'sex']
b = ['Dong', 38, 'Male']
d = dict(zip(a, b))
d

output:	 {'name': 'Dong', 'age': 38, 'sex': 'Male'}

ab的位置决定了谁是key谁是value，前者为key ，后者为value。

key和value数不一样(服从少数原则)

key多

x = [1, 2] 
y = ['a', 'b', 'c'] 
d = dict(zip(y, x)) 
print(d) 

output:	 {'a': 1, 'b': 2}

key少

x = [1, 2, 3, 4] 
y = ['a', 'b', 'c']
d = dict(zip(y, x)) 
print(d)

output:	 {'a': 1, 'b': 2, 'c': 3}

不用dict()函数(同样遵循少数原则)

a = ['name', 'age', 'sex']
b = ['Dong', 38, 'Male']
{i:j for i,j in zip(a,b)}
        
output:	 {'name': 'Dong', 'age': 38, 'sex': 'Male'}

字典长度

用len函数求得字典长度,字典长度就是key的个数

x = {1:1}
len(x)

output:  1

实战

• 定义一个Student类在该类中包括属性：姓名（name），年龄（age），成绩（score）（成绩包括语文、数学、英语三门）

方法：使用 get_name方法获取学生姓名；使用get_age方法获取学生年龄；使用get_course方法获取3门科目中成绩最高的课程名以及分数。

写好类以后用**zm=Student(‘zhangming’,20,[69,88,100])**测试，并输出结果。

class Student():
    def __init__(self,name, age, score):
        self.name = name
        self.age = age
        subject = ["语文","数学","英语"]
        self.score = dict(zip(subject,score))
    def get_name(self):
        print("该学生的姓名是：",self.name)
    def get_age(self):
        print("该学生的年龄是：",self.age)
    def get_score(self):
        x=max(self.score,key=self.score.get)
        print("该学生的最高成绩科目是:",x,",分数是：",self.score.get(x))
zm=Student('zhangming',20,[69,88,100])
zm.get_name()
zm.get_age()
zm.get_score()

列表

list()函数生成列表

在指定范围内生成列表

list(i for i in range(0,10))

在指定范围内生成指定间隔列表

list(range(1,10,3))

output:	 [1,4,7]

生成指定范围内能被指定数整除的列表

list(i for i in range(0,101) if i%6==0)

列表切片

切片时，从第0项起，[]中前项保留，后项舍去。

alist=[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
alist[2:5]
    
output： [5,6,7]

若要切最后一/几位

input：	alist=[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]	input： alist=[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
	     alist[-1:]											 alist[-4:]
    
output： [17]										output： [11，13，15，17]

元组亦是如此

数元素出现的次数

用count函数

a=[1,2,3,4,5,6,7,7,7,7]
a.count(7)

output:  4

用循环

a=[1,2,3,4,5,6,7,7,7,7]
x=0
for i in a:
    if i==7:
        x+=1
x

output:  4

增加/替换列表元素

切片法添加

a=list(range(1,10,3))
a[0:1]=[3]
a

output:  [3,4,7]

增加则将要增加的位置所对应下标填入,添加的元素将位于原下标对应位置前

a=list(range(1,10,3))
a[0:0]=[3]
a

output:  [3,1,4,7]

append函数添加

默认在列表尾部添加

    a=[1,3,4,5]
    a.append(6)
    a

output:  [1,2,3,4,5,6]

extend函数添加

a = ['name', 'age', 'sex']
a.extend("7")
a

output:  ['name', 'age', 'sex', '7']

括号中可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。

删除列表元素

删除指定位置的列表元素

del函数可以删除指定位置的列表元素

x = [1, 2, 3, 4]
del x[1]
x

output:  [1,3,4]

也可以删除指定范围的列表函数

和切片的位置同理

x = [1, 2, 3, 4]				x = [1, 2, 3, 4]
del x[1:]						del x[:-1]
x								x

output:  [1]					output:  [4]

pop()函数默认返回最后一项,默认删除最后一项

x = [1, 2, 3, 2, 3]				x = [1, 2, 3, 2, 3]
x.pop()							x.pop()
								x
output:	 3						output:  [1,2,3,2]

删除指定项

x = [1, 2, 3, 2, 3]				x = [1, 2, 3, 2, 3]
x.pop(1)						x.pop(1)
								x
output:	 2						output:[1,3,2,3]

删除列表指定值的元素

x = [1, 2, 3, 2, 3]
x.remove(2)

合并列表为字符串并用指定字符连接

用join函数将列表合并

''.join(list('hello world!'))

output:  'hello world!'

在’'里添加想作为分隔符的字符

'0'.join(list('hello world!'))

output:  'h0e0l0l0o0 0w0o0r0l0d0!'

枚举列表中元素

s = [2,5,8,3,6,9] 
for i in enumerate(s):
	print i
    
output:	 (0, 2)
         (1, 5)
         (2, 8)
         (3, 3)
         (4, 6)
         (5, 9)

若想选择索引开始数,则将enumerate(s,1),此时从1开始索引

元组 列表 字符串都可以用此方法遍历

将某元素插入列表中的某位置

x = [1, 2, 3]
x.insert(0, "s")
x

output:  ["s",1,2,3]

括号前面的代表插入后,新插入元素的位置

排序

sort函数排序

a=[1,5,6,7,3,7,7,2,4,6,4,2]
a.sort()
a

output:  [1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 7]

还可以选择顺序倒序排序

a=[1,5,6,7,3,7,7,2,4,6,4,2]
a.sort(reverse=True)	#reverse=False时,将不进行倒序排序
a

output:  [7, 7, 7, 6, 6, 5, 4, 4, 3, 2, 2, 1]

sorted函数排序

a=[1,5,6,7,3,7,7,2,4,6,4,2]
sorted(a)

output:  [1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 7]

同样的也可以选择顺序倒序排序

a=[1,5,6,7,3,7,7,2,4,6,4,2]
sorted(a,reverse=True)

output:  [7, 7, 7, 6, 6, 5, 4, 4, 3, 2, 2, 1]

关于列表的赋值

map括号里的str代表了赋值给变量的类型

x = [1, 3, 2]
a, b, c = map(str,sorted(x))
c

output:  "2"

列表的条件过滤

利用filter函数过滤掉不符合条件的元素，返回一个迭代器对象:接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

list(filter(lambda x: x>5, range(10)))

output:  [6,7,8,9]

字符串

替换字符

利用replace函数

x = 'hello world'
x.replace('l', 'g')

output：'heggo worgd'

寻找字符位置

利用find函数

x = 'hello world.'
x.find('o')

output:  4

find从左向右寻找子序列并输出其最近位置，若子序列不存在则返回-1。

利用index函数

x = 'hello world.'
x.index('o')

output:  4

index从左向右寻找子序列并输出其最近位置，若子序列不存在则报错。

利用rfind函数

x = 'hello world.'
x.rfind('o')

output:  7

rfind从右向左寻找子序列并输出其最近位置，若子序列不存在则返回-1。

利用rindex函数

x = 'hello world.'
x.rindex('o')

output:  7

rindex从右向左寻找子序列并输出其最近位置，若子序列不存在则报错。

检查字符串是否以指定子字符串开头

'Beautiful is better than ugly.Be'.startswith('Be', -2,)

output:  True

startswith(‘Be’, -2,)的括号中，-2代表开始位置，-2的逗号后代表结束位置

对字符串进行分割

利用正则表达式方法

分割后返回表格

可以在split()的括号里添加maxsplit=num用以规定分隔符使用的数量。

import re
a='Beautiful, is; better*than\nugly'
# 四个分隔符为：,  ;  *  \n
x= re.split(',|; |\*|\n',a)
print(x)

output：  ['Beautiful', ' is', 'better', 'than', 'ugly']

利用split方法

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。默认为 -1, 即分隔所有。

str.split(str="", num=string.count(str))

引号中可以输入自己想要的分隔符，默认所有的空字符包括空格、换行(n\）、制表(n\）

'hello world.'.split(" ")

分割后返回表格

str = "Line1-abcdef \nLine2-abc \nLine4-abcd"
print(str.split( ))      # 以空格为分隔符，包含 \n
print(str.split(' ', 1 )) # 以空格为分隔符，分隔成1+1个（切一刀）

output：  ['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
		  ['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

用指定字符延长字符串至指定长度

利用ljust()函数

a='abc'
a.ljust(8,'5')

output:  'abc55555'

2.模块调用

re模块

所有正则表达式都会在调用的时候引入re模块

匹配条件的常用字母代号

^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[…]	用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’
[^…]	不在[]中的字符：^abc匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	精确匹配 n 个前面表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。
re{ n,}	匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。“o{1,}” 等价于 “o+”。“o{0,}” 则等价于 “o*”。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	对正则表达式分组并记住匹配的文本
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (…), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#…)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。

\w	匹配字母数字及下划线
\W	匹配非字母数字及下划线
\s	匹配任意空白字符，等价于 [ \t\n\r\f]。
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B	匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\n, \t, 等	匹配一个换行符。匹配一个制表符。等
\1…\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

匹配字符串位置

re.match 函数尝试从字符串的起始位置匹配一个模式，若起始位置匹配成功，则显示长度、位置及匹配到的字符；如果不是起始位置匹配成功的话，match()就返回none。

#匹配失败
print(re.match('efg', 'defg'))

output:  None

#匹配成功
print(re.match('de','defg'))

output:  <re.Match object; span=(0, 2), match='de'>

re.search函数尝试从整个字符串匹配一个模式，若匹配成功，则显示长度、位置及匹配到的字符，若匹配失败，则返回None。

print(re.search('efg', 'defg'))

output:  <re.Match object; span=(1, 4), match='efg'>

findall函数在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果无匹配项，则返回空列表。

re.findall('\d+?', 'abcd1234')

output:  ['1', '2', '3', '4']

检索和替换字符

re.sub函数可以替换字符串中的匹配项

re.sub('\d+', '1', 'a12345bbbb67c890d0e')

output:  'a1bbbb1c1d1e'

3.实例

init生成实例对象

• 按照以下提示尝试定义一个矩形类并生成类实例对象：

  属性：长、宽

​ 方法：获得矩形的周长；获得矩形的面积。

class jvxing:
    def __init__(self,len,width):
        self.len=len
        self.width=width
    def zhouchang(self):
        c=(self.len+self.width)*2
        print("周长是：",c)
    def area(self):
        s=self.len*self.width
        print("面积是：",s)
d=jvxing(5,4)
d.zhouchang()
d.area()

• 为一元二次方程设计一个类名为Equation的类，这个类包括：

  1）代表3个系数的成员变量a, b, c；

  2）一个名为getDiscriminant()的方法返回判别式的值；

  3）一个名为getRoot1和getRoot2的方法返回等式的两个根

class Equation:
    def __init__(self,a,b,c):
        self.a=a
        self.b=b
        self.c=c
    def getDiscriminant(self):
        delta=self.b**2-4*self.a*self.c
        print(delta)
    def getRoot1(self):
        delta=self.b**2-4*self.a*self.c
        x1=(-self.b+delta**0.5)/2*self.a
        if delta>=0:
            print(x1)
        else:
            print("此方程没有实根")
    def getRoot2(self):
        delta=self.b**2-4*self.a*self.c
        x2=(-self.b-delta**0.5)/2*self.a
        if delta>0:
            print(x2)
        elif delta==0:
            print("此方程只有一个根")
        else:
            print("")
gen=Equation(1,2,1)
gen.getDiscriminant()
gen.getRoot1()
gen.getRoot2()