Python笔记-5 变量那些事（2）string

String

基础知识

----字符串的形式

• 单行字符串
  • 形式： 使用单引号（’ ‘）或者双引号（’’ ‘’）
  • 举例：‘abc’ , “123”;
  • 注意：在单行字符串中如果要进行换行必须加换行符“\”，比如

# 定义字符串
str = "abc\
def\
123"
# 打印字符串
print(str)
# 输出结果为(在同一行）
# abcdef123

• 多行字符串
  • 形式：使用三个双引号(""" “”")或者单引号（’’’ ‘’’）
  • 举例：’’‘abcdef123’’’
  • 注意：多行字符串中换行的话不需要""

# 定义字符串
str = """abc
def
123"""

print(str)
# 输出结果(式多行输出）
# abc
# def
# 123

----原字符与转义符

• 转义字符
  • 定义： 一些特定的字符在字符串中需要进行转义才能正常输出例如"\",在字符串中想要输出"\",必须这样写"\\"（此处的\\就是转义字符）
  • 其他的一些常见的转义字符
    • \’ —>单引号
    • \"—>双引号
    • \t—>横向制表符
    • \n—>换行符
    • \r—>回车
    • \v—>纵向制表符
    • \f—>换页
  • 例子

# 定义包含转义字符的字符串
sstr1 = "ab\\c"
sstr2 = "\'abc\'"
sstr3 = "ab\tc"
sstr4 = "ab\t\tc"
sstr5 = "ab\\tc"
sstr6 = "ab\nc"
for _ in range(6):
    print(eval("sstr"+str(_+1)))#eval()函数返回的字符串是被当作变量名
# 输出结果
# ab\c
# 'abc'
# ab	c
# ab		c
# ab\tc注意sstr5中有\\t的部分，在进行这部分处理的时候会读取前两个\\返回\，这个\是输出的结果，不会再影响t，然后再处理t时就把t作为普通的字符处理了，因为t之前没有\了
# ab	这个和下面的c时同一个字符串输出的结果
# c

• 原字符
  • 由上面我们知道了一些转义字符，它们会起到相应的特殊功能，比如\n在代码中时可见的，但是在输出结果中是不可见的，而是体现在换行上。那么，如果想不想让字符串中的转义字符起作用，而是想让其在输出结果中可见，可以通过将其转换成原生字符来实现
  • 转换方式
    • 字符串前面加r或者R
    • 使用函数repr()

# 加r
str1 = r'ab\tc'
print(str1)
# output-> ab\tc
# 加R
str2 = R'ab\tc'
print(str2)
# output-> ab\tc
# 使用函数repr
str3 = 'ab\tc'
print(repr(str3))
# output->'ab\tc'
# repr函数的实现就是在字符串出现\的前面加上一个\

• 原字符转换成转义字符
  • 使用eval()函数将原字符串转换为转义字符串
  • 上面的代码中你会发现一个问题，就是前两种的输出结果没有引号，而使用repr函数的输出结果却有引号，你可能觉得这不是什么大问题，但是bug总会突然来到你面前，然后say surprise！！！
  • 下面的代码将会解释这个问题

# 定义两个字符串变量
str1 = "abc\tabc"	# 这个字符串中的转义字符起作用
str2 = r"abc\tabc"	# 这个是原字符串，转义字符不起作用
print(str1)
print(str2)
print(eval(repr(str1)))
print(eval("'"+str2+"'"))
# 输出结果
# abc abc
# abc\tabc
# abc abc
# abc abc
# print(eval(repr(str1)))解析
	# str1是一个包含转义字符的字符串，且转义字符会起到作用，正如print(str1)的输出结果，
	# repr(str1)的返回结果是'abc\tabc';将这个值传入eval()函数，转义字符就可以起作用了，输出结果为 abc abc
# print(eval("'"+str2+"'"))
	# 由print(str2)的结果可以看出abc\tabc没有引号，所以将str2直接传入eval()函数就等于将不含有引号的abc\tabc传入，
	# 而python代码中只有带引号才被识别为字符串，所以abc\tabc在代码中不被当作字符串，eval（）的参数是字符串，所以，
	# 必须将abc\tabc用引号处理成字符串才行，否则就会报错！

• eval()函数的部分扩展 参考博客 ->link
  • eval是Python的一个内置函数，这个函数的作用是，返回传入字符串的表达式的结果。
  • eval(expression[, globals[, locals]])
    • expression ： 表达式，要是一个字符串
    • globals ： 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
    • locals ： 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
  • 命名空间
    • python是用命名空间来记录变量的轨迹的，命名空间是一个dictionary，键是变量名，值是变量值。
    • 在一个 Python 程序中的任何一个地方，都存在几个可用的名字空间。每个函数都有着自已的名字空间，叫做局部名字空间，它记录了函数的变量，包括函数的参数和局部定义的变 量。
    • 每个模块拥有它自已的名字空间，叫做全局名字空间，它记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。还有就是内置名字空间， 任何模块均可访问它，它存放着内置的函数和异常。
    • python的全局名字空间存储在一个叫globals()的dict对象中；局部名字空间存储在一个叫locals()的dict对象中。可以用print (locals())来查看该函数体内的所有变量名和变量值。
  • 例子
    • 1、简单表达式print(eval(‘1+2’))输出结果：3
    • 2、字符串转字典print(eval("{‘name’:‘linux’,‘age’:18}")输出结果：{‘name’:‘linux’,‘age’:18}
    • 3、传递全局变量print(eval("{‘name’:‘linux’,‘age’:age}",{“age”:1822}))输出结果：{‘name’: ‘linux’, ‘age’: 1822}
    • 4、传递本地变量age=18print(eval("{‘name’:‘linux’,‘age’:age}",{“age”:1822},locals()))输出结果：{‘name’: ‘linux’, ‘age’: 18}
  • 所以应该就明白前面用到eval函数的地方了吧。
  • 需要注意的一点就是eval函数不安全，因为它可以执行字符串的内容，所以你可能一不小心就把某个文件删掉了！

----占位符

• 什么是占位符—占位符就好比提前在一个作为上写上一个类别的名字，标明这个位置可以放上任何一个该类别的具体物品且只能放该类物品。
• 使用占位符的好处时可以提前打好格式，也容易改变具体的值。
• 常用的占位符
  • 字符：
    • %s—>字符串
    • %r---->非转义功能的字符串
    • %c—>单个字符
  • 数字（整数）
    • %d—>十进制（%nd，n表示输出的总的长度）
    • %i---->十进制
    • %o—>八进制
    • %x—>十六进制
  • 数字（浮点数）
    • %f—>浮点数（%m.nf：m表示总长度，n表示小数点后几位）
    • %F—>浮点数
  • 数字（指数）
    • %e(e为基）
    • %E(E为基）
  • 数字（指数或者浮点数）
    • %G
    • %g
• 举例

# 下面的abc,123,0.0都是随便打的字符串无任何含义
# 字符
print("abc: %s" % "abc")		# 输出：abc: abc
print("abc: %s%s" % ("abc","abc"))	# 输出：abc: abcabc
print("abc: %r" % "abc")		# 输出：abc: 'abc'
print("abc: %s" % "abc\tabc")		# 输出：abc: abc		abc
print("abc: %r" % "abc\t" )		# 输出：abc: 'abc\t'
print("abc: %c" % 97)			# 输出：abc: a
print("abc: %c" % 'a')			# 输出：abc: a
# 这里我们可以看出占位符的具体作用了，就是用后面的字符串代替前面的占位符。
# 注意点：1）当使用多个占位符时后面的字符或这数字需要存放在一个括号里。2）%s时，转义字符有效；%r时，转义字符无效；3）%c可以传入字符或者字符对应的ASCII码。

# 整数
print("123: %d" % 11)		# 输出：123： 11
print("123: %1d" % 11)		# 输出：123： 11
print("123: %2d" % 11)		# 输出：123： 11
print("123: %3d" % 11)		# 输出：123：  11
print("123: %4d" % 11)		# 输出：123：   11	
print("123: %o" % 11)		# 输出：13
print("123: %x" % 11)		# 输出：b
# 前面说过%nd中的n表示的是输出数字的位数，但是要注意到实际的数字大于或者n时，输出数字的位数按照实际数字，当实际数字小于n时，输出的位数按照n,这样不够的位数用空格表示，由前五个print就可以看出（默认n等于实际数字位数）；
# 输出八进制数时，需要传入十进制数，但是会自动转换成八进制数输出，如上十进制数11转化成八进制数后位13
# 输出十六进制数时，需要传入十进制数，但是自动转化成十六进制数输出，如上十进制数11转化成十六进制数为b。

# 浮点数（F与f作用相同）
print("1->"+"0.0: %f" % 2.0)
print("2->"+"0.0: %2.1f" % 2.0)
print("3->"+"0.0: %2.1f" % 2)
print("4->"+"0.0: %.4f" % 2)
print("5->"+"0.0: %1.4f" % 2)
print("6->"+"0.0: %4.1f" % 2)
# 输出
#1->0.0: 2.000000
#2->0.0: 2.0
#3->0.0: 2.0
#4->0.0: 2.0000
#5->0.0: 2.0000
#6->0.0:  2.0
#%m.n中m表示总长度，n表示小鼠点后的位数
#由1、2可知默认情况下，小数点后由6位
#由2、3可知输入的可以位整数或者浮点数
#由4、5、6可知，m位数默认与实际相同；当m<n时，m相当于没作用；反之，不够位数时，用空格补充；小数点也算一位！

# 指数
print("e: %e" % 300)
print("e: %E" % 300)
#输出
#e: 3.000000e+02（相当于3X10^2)
#e: 3.000000E+02

str.format的简单用法

print('{0:a>10d} {1:b<10.3f} {2:c^10}'.format(5, 0.5, "python"))
# 输出：aaaaaaaaa5 0.500bbbbb ccpythoncc
# 前面字符串中的每一个大括号对应后面括号里的一个数值；现在看其中的第一个大括号，0表示索引，也就是对应后面括号里的哪个数值，索引从0开始（程序员都知道）；冒号后面的第一个参数a是补齐字符（你可以自由选择使用什么字符来填充）；冒号后的第二个参数是对齐方式，>是右对齐，^是居中对齐，<是左对齐；冒号后面剩余的参数和上面的%的用法一样。

函数

# 下面我是用：来表示输出
# input()
	 # 介绍：input()函数是I/O输入的函数，用来提示并且获取用户的输入，被输入的内容都被当成字符串返回
 	 # 使用方法：a = input("请输入：")，括号内的提示文字自行描述或者不描述
 a = input("请输入: ")
 ：请输入：52	# 这里我们输入一个值52
 print(type(a), a)
 :<class 'str'> 52	# a的值是52，类型是字符串
 
# strip()
	# 介绍：strip()函数可以去掉字符串两端的空白字符或者换行符，返回处理后的字符串
	# 使用方法：str.strip()
a = "    abc abc    "
print(a, '\n', a.strip())
:     abc abc    
:abc abc	#把前后的空格去除

# lstrip()
	# 介绍：lstrip()函数可以只去除字符串左侧的换行符和空白字符，返回处理后的字符串
	# 使用：str.lstrip()
# rstrip()
	# 介绍：rstrip()函数可以只去掉字符串右面的换行符和空白字符，返回处理后的字符串
	# 使用：str.rstrip()
	
# len()
	# 介绍：返回字符串的长度
	# 用法：len(str)
a = 'abc abc'
print(len(a))
:7			# 空白字符等字符也算
print(len('\n'))
:1			# 一个特殊字符算一个

# in
	# 介绍：判断一个字符或者字符串是否在字符串中，如果在则返回True，反之返回False。
	# 用法： a in str
a = "abc abc"
print('a' in a)
：True
print('ab' in a)	
：True
print('a' not in a)
:False

# split()
	# 介绍：split()函数可以根据某个分割符将一个字符串分割，返回一个列表
	# 使用：str.split("_") 括号内的参数位分割符，可以根据实际选择
a, b = "abc_abc_abc", "abc def hgk"
print(a.split('_'), '\n', b.split(' '))
:['abc', 'abc', 'abc'] 
  ['abc', 'def', 'hgk']	# 分割符不显示

# join()
	# 介绍：字符串拼接函数，使用某个连接符将字符串拼接到一起，返回拼接后的字符串
	# 使用：'_'.join([str1,str2])
a, b, c = 'ab', 'cd', 'ef'
print(''.join([a,b,c]))
:abcdef
print('_'.join([a,b,c])
:ab_cd_ef
# 也可以写成'_'.join((a,b,c));但是不能写成'_'.join(a,b,c);必须把几个字符串放在一个列表或者元组（括号）中作为参数传入函数的括号内。

# title()
	# 介绍：将字符串中每个单词的首字母转换成大写
	# 使用：str.title()
a = 'abc Def 123'
print(a.title())
：Abc Def 123

# capitalize()
	# 介绍：将整个字符串的首字母转换成大写
	# 使用：str.capitalize()
a = 'abc DEF 123'
print(a.capitalize())
:Abc def 123

# upper()
	# 介绍：将所有的字符转换成大写
	# 使用：str.upper()
a = 'abc deF q12'
print(a.upper())
:ABC DEF Q12	

# lower()
 # 介绍：将所有的字符转换成小写
 # 使用：str.lower()
a = 'abc deF q12'
print(a.lower())
:abc def q12

# count()
	# 介绍：计算字符串中某个字符出现的次数
	# 使用：str.count('x')
a = 'abcdefajaaca'
print(a.count('a'))
:5
	
# find()
	# 介绍：查找字符串中是否包含某个字符,如果存在就返回其下标，如果不存在，就返回-1
	# 使用：str.find('x')
a = 'abcdef'
print(a.find('b'), a.find('g'))	
:1, -1		
b = 'aaaa'
print(b.find('a'))
:0		# 有多个相同的字符时，就返回第一个的下标

# index()
	# 介绍：返回某个字符的下标，这个字符必须存在于这个字符串中，否则会报错
	# 使用：str.index()
a = 'abcdef'
print(a.index('b')) 
:1
b = 'aaaa'
print(b.index('a'))
:0 		# 当有多个相同的字符时，返回第一个字符的下标

# replace()
	# 介绍：将字符串中的某一部分替换成其他的字符
	# 使用：str.replace(s1, s2)
a = 'abc'
print(a.replace('a', 'b'))
:bbc
	
# center()
	# 介绍：将字符串放在中间，两侧用指定字符填充。
	# 使用：str.center(n,'_')， n时指字符串的长度，第二个参数是填充字符
a = 'abc'
print(a.center(9, '-'))
:---abc---
 	
# startswith()
	# 介绍：判断字符串是否以指定的字符或者字符串开头，如果是则返回True，反之返回False
	# 使用：str.startswith('x')
a = 'abcdef'
print(a.startswith('a'),a.startswith('b'),a.startswith('ab'))
:True False True
	
# endswith()
	# 介绍：判断字符串是否以指定的字符或字符串结尾，如果是则返回True，反之则返回False
	# 使用：str.endswith('x')
a ='abcdef'
print(a.endswith('f'),a.endswith('a'),a.endswith('ef'))
:True False True
	
# isalnum()
	# 介绍：判断字符串中是否只有字符和数字
	# 使用：str.isalnum()
a, b, c, d = 'abc', '123', 'abc123', 'ab12--'
print(a.isalnum(), b.isalnum(), c.isalnum(), d.isalnum())
:True True True False
	
# isalpha()
 	# 介绍：判断字符串是否只包含字符
 	# 使用：str.isalpha()
 a, b = 'abc', 'abc1'	
 print(a.isalpha(), b.isalpha())
 :True False
 
# isdigit()
	# 介绍：判断字符串中是否只有数字
	# 使用：str.isdigit()
a, b = '123', '123a'
print(a.isdigit(), b.isdigit())
:True False

# isspace()
	# 介绍：判断字符串中是否全是空白字符
	# 使用：str.isspace()
a = 'abc '
print(a.isspace())
:False

# islower()
	# 介绍：判断字符串是否全是小写
	# 使用：str.islower()
a = 'abC'
print(a.islower())
:False	
# isupper()
	# 介绍：判断字符串是否全是大写
	# 使用：str.isupper()
a = 'Abc'
print(a.isupper())
:False	
# istitle()
	# 介绍：判断字符串中每个单词是否以大写字母开头
	# 使用：str.istitle()
a = 'Abc def'
print(a.istitle())
:False