python学习笔记（1）

"单下划线" 开始的变量叫做保护变量，只有类对象和子类对象能访问到这些变量。
 
"双下划线" 开始的是私有成员，只有类对象自己能访问，连子类对象也不能访问到这个数据。

import keyword
print(keyword.kwlist)

print(dir(__builtins__))

a = 2.5
print(type(a))

print('hello n world')
print('hello \n world')

print(r'hello \n world')

print(r'let's go ')

print(r'let\'s go ')

 +     加
 -     减
 *     乘
 /     除
 **    幂 - 返回x的y次幂
 //    取整除 - 返回商的整数部分（向下取整）
 %   取模 - 返回除法的余数

print(2 ** 4)    # 16
print(5 // 2)    # 2
print(5 % 3)     # 2

 +=     加法赋值运算符	  
 -=     减法赋值运算符
 *=     乘法赋值运算符
 /=     除法赋值运算符
 **=    幂赋值运算符       c **= a 等效于 c = c ** a
 //=    取整除赋值运算符	  c //= a 等效于 c = c // a
 %=     取模赋值运算符	  c %= a 等效于 c = c % a

string1 = 'csdn'
string2 = "csdn"
string3 = '''csdn'''
string4 = """csdn"""

print(string1)
print(string2)
print(string3)
print(string4)

 + ，format格式化的方式

name = 'zhangsan'
age =  10

string1 = '我的名字叫{}, 年龄{}岁'.format(name, age)	
print(string1)
#输出    我的名字叫zhangsan，年龄10岁

string2 = '我的名字叫' + name + ', 年龄' + str(age) + '岁'
print(string2)
#输出    我的名字叫zhangsan，年龄10岁

name = 'zhangsan'
print(name * 2) 
#输出  zhangsanzhangsan

string='hello'

print(string[0])	#第一位      输出h

print(string[-1])	#最后一位    输出o

print(string[1:3])	#从第二位到第四位，不包括第四位（即包前不包后）    输出el

print(string[::2])	#从开头到末尾，步长为2            输出hlo

money = int(input('input current money:'))
if money > 400:  
	money = money * 0.85
else:  
	money = money * 0.95

print('实际支付{}'.format(money))

rmb=int(input('输入老板给你加的工资'))
if rmb > 10000:
    print('我很开心')
elif rmb > 1000:
    print('还行')
else:
    print('不开心')

i = 0
string = 'wo xi huan xue xi'
while i < len(string):  
	print(string[i])  
	i += 1
#或者	
for s in string:  
	print(s)

print('{},{},{}'.format('li', 'girl', 32))

print('{0},{1}'.format('li', 32))

print('{name}, {sex}, {age}'.format(age=32, sex='male', name='li'))

print('{:<7} and {:>9}'.format('hello','world'))

print('{:<3} and {:>3}'.format('hello','world')) 
print('{:<5} and {:>5}'.format('hello','world')) 

print('{:0>9}'.format('ihszg'))
print('{:a<8}'.format('ihszg'))
print('{:*^10}'.format('ihszg'))

list1 = ['Google', 'Runoob', 1997, 2000]
print (list1[0:2])	    #['Google', 'Runoob']
print (list1[0:4:2])	#['Google', 1997]

listupdate = ['Google', 'sina', 1997, 2000] 
print ("第三个元素为 : ",listupdate[2]) 
listupdate[2] = 2001 
print ("更新后的第三个元素为 : ", listupdate[2])
listupdate.append('99')
print (listupdate)

listupdate = ['hello', 'world', 2020, 08]    
listupdate.insert(3, '9')  #在第三位插入字符串9（程序员都是从0开始计数的）
listupdate.insert(4, 6)  #在第四位插入数字6
print (listupdate)

import re 	# python的的正则库
strr = '刘三王五李四张三'
pat = '王五'	#特殊的正则表达式
mm=re.search(pat,strr)	 #返回第一个匹配到的文本和对应索引

print(mm)
print(mm.span(),mm.group())	#span()对应的索引；group()对应的文本

import re
with open('D:\\202008\\射雕英雄传.txt','rb+') as f:   #路径需用\转义，即要以\\分割
  data=f.read().decode('utf-8')      #以utf-8编码方式解码
print(data)       #输出全文

pat_one='郭靖'
pat_two='黄蓉'

name_g_number = re.findall(pat_one,data)    #找到所有“郭靖”
name_h_number =re.findall(pat_two,data)

print(name_g_number)      #输出所有“郭靖”
print(name_h_number)

print('郭靖:',len(name_g_number))    #输出“郭靖”出现的次数
print('黄蓉:',len(name_h_number))

strr = '广州，湖北，天津，贵州'
pat = '湖北'	#特殊的正则表达式
mm=re.search(pat,strr) 	#返回第一个匹配到的文本和对应索引
print(mm)

\d ：数字
\D : 非数字
\w ：数字、字母、下划线、中文
\W : 非\w
\s ：所有的空白字符包,括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]
\S : 非空白

import re
tele_p='13950781934'
pat='\d\d\d\d\d\d\d\d\d\d\d'   #匹配11个数字
print(re.search(pat,tele_p))

import re
ch='abcdefghkfsa'    
pat='\w\w\w'      #匹配三个数字、字母、下划线或中文（只输出最先匹配到的符合条件的三个）
print(re.search(pat,ch))

import re
tele_p='13950781934'
pat='[0-9]*'
print(re.search(pat,tele_p))

[a-z][A-Z]

[\u4e00-\u9fa5]

import re

strr='#$%^&\*12^&\*@@ab%……&你好'

pat_c=r'[\u4e00-\u9fa5][\u4e00-\u9fa5]'
pat_d=r'[0-9][0-9]'
pat_b=r'[a-z][a-z]'

print(re.search(pat_c,strr))
print(re.search(pat_d,strr))
print(re.search(pat_b,strr))

[ ]    只匹配其中的一个原子 

[^]    只匹配"除了"其中字符的任意一个原子 

[0-9]　匹配0-9任何一个数字 

[a-z]　匹配小写a-z任何一个字母 

[A-Z]　匹配大写A-Z任何一个字母

import re
stri = '13799000123|15799000127|18799000122'
pat1 = '...'
pat2 = r'187\d+122$'
pat3 = r'^137\d+'
pat4 = r'8*'
print(re.search(pat1,stri))
print(re.search(pat2,stri))
print(re.search(pat3,stri))
print(re.search(pat4,stri))

"{n}"        #重复n次　　

"{n,m}"	     #重复n到m次　

"{n,}"	     #重复至少n次或更多次   

import re
passwd = '12345678'
pat1='\d{6}'
pat2='\d{6,8}'
pat3='\d{6,}'
print(re.search(pat1,passwd))
print(re.search(pat2,passwd))
print(re.search(pat3,passwd))

strr='aa<div>test1</div>bb<div>test2</div>cc'
pat1=r"<div>.*</div>"
print(re.search(pat1,strr)) #贪婪模式

strr='aa<div>test1</div>bb<div>test2</div>cc'
pat1=r"<div>.*?</div>"
print(re.findall(pat1,strr)) #非贪婪模式

import re

line = "this model server 456"
pat1 = r"th"
pat2 = r"mo"
print(re.match(pat1, line))
print(re.match(pat2, line))

import re
stri='python123123java'
pat1 = re.compile('\d+')
print(re.search(pat1,stri))

string = 'www.baidu.com'

print('w' in string)	     #返回ture
print('w' not in string)	 #返回false

string = 'www.baidu.com'

print(string.find('baidu'))      #返回4
print(string.find('w', 3, 7))    #返回-1
# find 查找不到时，返回-1
# 如果查找到的话，返回对应的下标

print(string.count('w'))	#查找返回个数,如果查找不到 返回0

s = ' h  hello  world q '
s1 = ' h  hello  world q '
s2 = 'h  hello  world q '
print(s.strip())  #默认去掉左右空格
print(s1.rstrip()) #默认去掉右侧空格
print(s2.lstrip('h'))  #去掉左侧h

hell\*o     匹配     hell*o

t = 'hacKera'

# 1、capitalize() 首字母大写
print(t.capitalize())

# 2、center()  返回以长度和宽度为中心的字符串。填充使用指定的填充字符完成(默认为空格)
print(t.center(8))

# 3、count()返回子字符串子字符串中不重叠的次字符串(开始:结束)。可选参数start和end是解释为切片表示法。
print(t.count('a',2,4))

# 4、endswith()
#如果S以指定的后缀结尾，则返回True，否则返回False。可选的开始，测试从那个位置开始。
# 使用可选结束，停止在那个位置比较S。后缀也可以是字符串的元组来尝试。字符从1开始
print(t.endswith('k',2,4))

# 5、startswith()
print(t.startswith('c',2,4))
# 如果S以指定的前缀开头，则返回True，否则返回False。可选的开始，测试从那个位置开始。
# 使用可选结束，停止在那个位置比较S。前缀也可以是字符串的元组来尝试。字符从零开始

# 6、len(string) 求字符串长度
print(len(t))

# 7、title()返回一个带标题的S，即以标题大小写开头的单词字符，所有剩下的大小写字符都是小写的。
print(t.title())

# 8、upper()  将字符串全部大写返回
print(t.upper())

# 9、lower()   将字符串全部小写返回
print(t.lower())

# 10、join()   属性中字符串的连接返回一个字符串可迭代的元素之间的分隔符是S
				# 将序列中的元素以指定的字符连接生成一个新的字符串
s1 = "-"
string4 = ("a", "b", "c", "d", "e", "f")
print(s1.join(string4))
print(t.join('-'))

# 11、replace()返回包含所有子字符串的S的副本
# 旧的被新的取代。如果可选参数计数为给定，只替换出现的第一个计数。
print(t.replace('a','era',1))

# 12、split()   返回以S表示的单词列表，使用sep作为分隔符的字符串。如果给定maxsplit，最大值为maxsplit
# 分割完成。如果sep未指定或为None，则为any空格字符串是分隔符，空字符串是分隔符从结果中删除
print(t.split('ac'))

# 13、find()返回S中找到子字符串子的最低索引，使子包含在S[start:end]中。
# 可选参数的开始和结束被解释为片表示法,没有则返回-1
print(t.find('e',1,6))

# 14、rfind()
#返回S中找到子字符串子的最高索引，使子包含在S[start:end]中。可选参数的开始和结束被解释为片表示法。
#若有多个字符，则只显示最高位,
print(t.rfind('a',0,7))

# 15、index()返回S中找到子字符串子的最低索引，
# 使子包含在S[start:end]中。可选 参数的开始和结束被解释为片表示法。未找到子字符串时引发ValueError
print(t.index('c',1,3))

# 16、rindex()返回S中找到子字符串子的最高索引，
# 使子包含在S[start:end]中。可选参数的开始和结束被解释为片表示法。未找到子字符串时引发ValueError
print(t.rindex('a',1,3))

# 17、isalnum()
# 如果S中的所有字符都是字母数字，则返回True,S中至少有一个字符，否则为假
print(t.isalnum())

# 18、isalpha()
# 如果S中的所有字符都是字母，则返回TrueS中至少有一个字符，否则为假
print(t.isalpha())

# 19、isdigit()
#如果S中的所有字符都是数字，则返回TrueS中至少有一个字符，否则为假
print(t.isdigit())

# 20、islower()
#如果S中所有大小写字符都是小写的，则返回True在S中至少有一个大小写混合字符，否则为False
print(t.islower())

# 21、isnumeric()
# 如果S中只有数字字符，则返回True， 假的,否则返回false
print(t.isnumeric())

# 22、istitle()
# 如果S是一个带标题的字符串，并且至少有一个，则返回True
# 字母S中的字符，即只能使用大写字符和标题字符 只跟随大小写字符和小写字符。否则返回假
print(t.istitle())

# 23、isupper()
# 如果S中的所有大小写字符都是大写，则返回True
# 在S中至少有一个大小写混合字符，否则为False
print(t.isupper())

# 24、ljust(width[,fillchar])
# 在Unicode长度和宽度的字符串中返回左对齐的S。填充使用指定的填充字符完成(默认为空格)
print(t.ljust(8,'b'))

# 25、rjust(width, [,fillchar])
# 返回长度和宽度为右对齐的字符串。填充使用指定的填充字符完成(默认为空格)
print(t.rjust(9,'a'))

# 26、rstrip()
# 返回字符串S的副本，并删除后面的空格。
# 如果给定字符而不是None，则删除字符中的字符。
print(t.rstrip('ack'))

# 27、strip([chars])
# 返回带有前导和结尾的字符串S的副本
# # 空格移除。如果给定字符而不是None，则删除字符中的字符
print(t.strip('kera'))

# 28、lstrip()
# 返回删除前导空格的字符串S的副本。
# 如果给定字符而不是None，则删除字符中的字符
print(t.lstrip('hac'))