python学习笔记：3、字符串与循环中的while

一、String（字符串）

什么叫做字符串？

  答:字符串是以单引号或双引号括起来的任意文本。
  note:字符串是不可变的，即创建一个字符串之后，不能改动字符串中的任何一个元素。（详细参考本文章字符串运算第三小节）

（一）创建字符串

str1 = "you reap what you sow"
str2 = "no pains no gains"
str3 = "You never know your luck"

（二）字符串运算

1.字符串连接

str6 = "You never"
str7 = "know your luck"
str8 = str6 + str7
print("str6 =",str6)
print("str7 =",str7)
print("str8 =",str8)
#通过编译的到结果可知str8讲两个字符串连接在一起
#故编译结果：str8 = You never know your luck

2.输出重字符串

str9 = "good"
str10 = str9 * 3
print("str10 =", str10)
#编译结果：str10 = goodgoodgood

3.访问字符串中的某一个字符

  方法：通过索引下标查找字符，索引从0开始。
  格式：字符串名[下标]
  note:空格也是一个字符。

str11 = "You never know your luck"
print(str11[1])
#str11[1] = "a"  会报错因为不能改变字符串里的值（字符串不可变）
#编译结果：o

4.截取字符串中的一部分

  假如我们创建一个字符串：str13 = “You never know your luck”
  str13[0]=Y  str13[1]=o  str13[2]=u  str13[3]=  str13[4]=n  str13[5]= e 依次类推。
  str13[3]内并不是什么都没有，里面是一个空格。

（1）从给定下标出开始截取到给定下标之前

  假如我们从str13 = "You never know your luck"中截取know your

str13 = "You never know your luck"
#从给定下标出开始截取到给定下标之前
str15 = str13[10:19]
print("str15 =", str15)
#编译结果：str15 = know your

（2）从头截取到给定下标之前

  假如我们从str13 = "You never know your luck"中从头截取到never结束。

str13 = "You never know your luck"
#从头截取到给定下标之前
str16 = str13[:5]
print("str16 =", str16)
#编译结果：str16 = You neve

（3）从给定下标处开始截取到结尾

  假如我们从str13 = "You never know your luck"中从k开始到结束。

str13 = "You never know your luck"
#从给定下标处开始截取到结尾
str17 = str13[10:]
print("str17 =",str17)
#编译结果：str17 = know your luck

二、格式化输出

  占位符：%d %s %f
  这里大家可以在编译器中自己动手体会一下，不再细说。

num = 10
str19 = "You never know your luck"
f = 10.1267
print("num =", num)   #编译结果：num = 10
print("num = %d" % (num))#称%d为占位符   #编译结果：num = 10
print("num = %d, str19 = %s" % (num, str19))#编译结果：num = 10, str19 = You never know your luck
#       %d %s %f 占位符
#                               精确到小数点后3位，会四舍五入
print("num = %d, str19 = %s, f = %.3f" % (num, str19, f)) #编译结果:num = 10, str19 = You never know your luck, f = 10.127

三、转义字符（\）

  将一些字符转换为有特殊含义的字符称为转义字符。

（一）换行符（\n）

num = 10
str19 = "You never know your luck"
f = 10.1267
print("num = %d\nstr19 = %s\nf = %.3f" % (num, str19, f))
'''
编译结果:
num = 10
str19 = You never know your luck
f = 10.127
'''

  但是我们如果需要很多换行的话print(“You\nnever\nknow\nyour\nluck”)这样看起来是不是眼花缭乱，很难阅读，我们可以这样写：

#python里打印多行可以这样写
print(
'''
You
never
konw
your
luck
''')

  这样可以和用换行符得到同样的结果。

（二）（ \ \ ）保证在程序中不会导致特殊的含义

1. \ \ n

  假如我们不想将“\n”作为换行符，只是在print输出时“\n”可以打印出来应该如何做？如下我们在“\n”前加一个转义字符“\”变成“\\n”，转义字符“\”使换行符“\n”没有任何特殊含义，这样我们就能打印出“\n”而不是把它作为换行符来用了。

print("You \\n never know your luck")  #想输出\n,在前面加\
#编译结果：You \n never know your luck

2. \ 'k

  假设我们要输出You never know your luck时，想要用单引号将know引起来得You never ‘know’ your luck，我们是否可以这样做呢？

print('You never 'know' your luck')

  直接将know用引号括起来，在我们编译过后会报错，为什么呢？这是因为You前面的引号和know前的引号对照将You never 引起来；know后面的引号和luck后的引号对照将your luck引起来，形成了两个字符串’You never  ‘和’  your luck’，但是中间的know又是什么呢？什么也不是，它在语法上出现了错误。所以编译器会报错，那么我们该如何做呢？这时候转义字符（\）又要上场了：

print('You never \'know\' your luck')
#输出结果：You never 'know' your luck

  转义字符“\”将单引号的含义“转（三声）”了，这样单引号就变成了字符串中数据的一部分了。
  下面用双引号的例子和上面说的是一样的，就不在解释了。

print("You never \"know\" your luck")
#输出结果：You never "know" your luck

  下面这种方式也是可以的，大家可以自己操作操作。

print("You never \'know\' your luck")
#输出结果：You never 'know' your luck

3.制表符（ \t ）

print("You\tnever")
#输出结果：You    never
#You和never中间有四个空格。

4.r

  如果字符串中有好多字符串都需要转义，就需要加入好多\,为了简化，python允许用r表格内部的字符串默认不转义。
  我们想要打印出 \\\t\\

print(r"\\\t\\")
#编译结果：\\\t\\

5.如何打印出路径

print(r"C:\Users\xlg\Desktop\Python-1704\day03")
print("C:\\Users\\xlg\\Desktop\\Python-1704\\day03")

  为
  note:
  Lunix系统路径样式：
  /root/Users/xlg/Desktop/Python-1704/day03
  Windows系统路径样式：
  C:\user\xlg\Desktop\Python-1704\day03

四、与字符串相关的函数

（一）eval( )：将字符串str当成有效的表达式来求值并返回计算结果。

  功能：将字符串str当成有效的表达式来求值并返回计算结果。
  我们先来探究一下字符串经过eval( )返回的值是一个什么类型。

num1 = eval("123")
print(num1)       #编译结果：123
print(type(num1)) #编译结果：<class 'int'>

  从中我们知道了字符串经过eval( )返回的值是一个整形。
  我们来看接下来的例子：

print(eval("+123"))  #编译结果：123
print(eval("-123"))  #编译结果：-123
print(eval("12+3"))  #编译结果：15
print(eval("12-3"))  #编译结果：9

  我们再来看两个例子：

print(eval("a123"))
print(eval("12a3"))

  当我们在编译器中编译过后会发现编译器报错了，这是因为字符串a123、12a3时没有办法进行运算的。

（二）len( )：返回字符串的长度(字符个数不是字节数)【包括空格】。

  功能：返回字符串的长度(字符个数不是字节数)【包括空格】。

print(len("You never know your luck"))
#编译结果：24
print(len("哈喽"))
#编译结果：2

  可知字符串“You never know your luck”的长度为24。字符串"哈喽"的长度为2。

（三）string.lower( )：转换字符串中大写字母为小写字母。

  功能：转换字符串中大写字母为小写字母。

str20 = "YOU Never KNOW your LUCK"
str21 = str20.lower()        
print("str20 = %s" %(str20))     #编译结果：YOU Never KNOW your LUCK
print(str21)                     #编译结果：you never know your luck
print(str20.lower())             #编译结果：you never know your luck

  这样我们将字符串“YOU Never KNOW your LUCK”转化成了“you never know your luck”。
  note：lower(str)功能的实现实际上是生成了一个新的字符串，而不是改变了原字符串，字符串是不能改变的。下面的upper(str)实质也是新生成了一个字符串，不是改变了原字符串。

（四）string.upper( )：转换字符串中小写字母为大写字母。

  功能：转换字符串中小写字母为大写字母。

str21 = "YOU Never KNOW your LUCK"
print(str21.upper())
#编译结果：YOU NEVER KNOW YOUR LUCK

（五）string.swapcase( )：转换字符串中小写字母为大写字母，大写字母为小写字母。

  功能：转换字符串中小写字母为大写字母，大写字母为小写字母。

str22 = "YOU Never KNOW your LUCK"
print(str22.swapcase())
#编译结果：you nEVER know YOUR luck

（六）string.capitalize( )：转换字符中首字母大写，其他小写。

  功能：转换字符串中小写字母为大写字母，大写字母为小写字母。

str23 = "YOU Never KNOW your LUCK"
print(str23.capitalize())
#编译结果：You never know your luck

（七）string.title( )：每个单词的首字母大写，其他小写。

  功能：每个单词的首字母大写，其他小写。

str24 = "YOU Never KNOW your LUCK"
print(str24.title())
#编译结果：You Never Know Your Luck

（八）string.center(width, fillchar)：返回一个制定宽度的居中字符串。

  功能：返回一个制定宽度的居中字符串，fillchar为填充的字符串,默认为空格填充。

str25 = "You never know your luck"
print(str25.center(40, "*")) #编译结果：********You never know your luck********
print(str25.center(40))  #默认填充空格   编译结果：        You never know your luck       

（九）string.ljust(width[, fillchar])：返回一个指定宽度的左对齐字符串。

  功能：返回一个指定宽度的左对齐字符串，fillchar为填充字符，默认空格填充。
  note:[ ]中括号里表示可以写可以不写,下面的函数也是这种情况。

str26 = "You never know your luck"
print(str26.ljust(40, "%")) #编译结果：You never know your luck%%%%%%%%%%%%%%%%
print(str26.ljust(40))  #默认填充空格   编译结果：You never know your luck

（十）string.rjust(width[, fillchar])：返回一个指定宽度的左对齐字符串。

  功能：返回一个指定宽度的右对齐字符串，fillchar为填充字符，默认空格填充。

str27 = "You never know your luck"
print(str27.rjust(40, "%"))  #编译结果：%%%%%%%%%%%%%%%%You never know your luck
print(str27.rjust(40))  #默认填充空格  编译结果：                You never know your luck

（十一）string.zfill(width)：返回一个长度为width的字符串，原字符串右对齐，前面补0。

  功能：返回一个长度为width的字符串，原字符串右对齐，前面补0。

str28 = "You never know your luck"
print(str28.zfill(40))  #编译结果：0000000000000000You never know your luck

（十二）string.count(str[, start][, end])：返回字符串中str出现的次数。

  功能：返回字符串中str出现的次数，可以指定一个范围，默认从头到尾。

str29 = "You never never never know your luck"
print(str29.count("never"))  #默认从头到尾  编译结果：3
print(str29.count("never", 15, len(str29)))   #编译结果：1

（十三）string.find(str[, start][, end])：从左向右检测str字符串是否包含在字符串中。

  功能：从左向右检测str字符串是否包含在字符串中，可以指定范围，默认从头到尾。得到的是第一次出现的开始下标[整个字符串中的下标],没有该字符串返回-1。

str30 = "You never never never know your luck"
#下标    0123456789..............
print(str30.find("never")) #编译结果：4
print(str30.find("good"))  #没有该字符串返回-1
print(str30.find("never", 15, len(str30)))  #编译结果：16

（十四）string.rfind(str[, start][, end])：从右向左检测。

str30 = "You never never never know your luck"
print(str30.rfind("never"))  #编译结果：16
print(str30.rfind("good"))  #没有该字符串返回-1
print(str30.rfind("never", 0, 15))  #编译结果：10

（十五）string.index(str, start=0, end=len(str))

  功能：start和end 填也行不填也行。index()和find()功能一样，只不过如果index()是str不存在的时候回报一个异常。index()比find()更加严谨。

str31 = "You never never never know your luck"
print(str31.index("never"))  #编译结果：4
#print(str31.index("good"))  找不到good报错

（十六）string.rindex(str, start=0, end=len(str))

  功能：start和end 填也行不填也行。rindex()和rfind()功能一样，只不过如果rindex()是str不存在的时候回报一个异常。rindex()比rfind()更加严谨。

str32 = "You never never never know your luck"
print(str32.rindex("never "))  #编译结果：16
#print(str32.rindex("good"))  找不到good报错

（十七）string.lstrip( )：截掉字符串左侧指定的字符，默认为空格。

str33 ="   You never know your luck"
print(str33.lstrip())   #将左侧的空格截掉  编译结果：You never know your luck

str33 ="*****You never know your luck"
print(str33.lstrip("*"))  #将左侧的*截掉   编译结果：You never know your luck

（十八）string.rstrip()：截掉字符串右侧指定的字符，默认为空格。

str34 ="You never know your luck      "
print(str34.rstrip())   #将右侧的空格截掉  编译结果：You never know your luck

str34 ="You never know your luck*****"
print(str34.rstrip("*")) #将右侧的*截掉  编译结果：You never know your luck

（十九）string.strip()：截掉字符串左右两侧指定的字符，默认为空格。

str35 = "*****You never know your luck*****"
print(str35.strip("*"))  #编译结果：You never know your luck

（二十）ord( )和chr( )

  功能：ord( ):将字符转化为它的ASCLL码值;chr( ):将ASCLL码置转化为对应的字符。

str36 = "a"
print(ord(str36))  #将字符a转化为它的ASCLL码值  编译结果：97
str37 = chr(97)    #将ASCLL码置转化为对应的字符
print(str37)       #编译结果：a

（二十一）string.split(str="",num)

  功能：以str为分隔符截取字符串,默认为所有的空字符，包括空格、换行(\n)
     以str为分隔符截取字符串，分割num次（num默认为 -1,即分隔所有）

str38 = "You**never**** know*****your***luck"
print(str38.split("*"))#编译结果：['You', '', 'never', '', '', '', ' know', '', '', '', '', 'your', '', '', 'luck']
print(str38.split("*",4))#编译结果：['You', '', 'never', '', '** know*****your***luck']

  例：判断一个句子中有多少个单词

str38 = "You**never**** know*****your***luck"
list39 = str38.split("*")
c = 0
for s in list39:
    if len(s) > 0:
        c += 1
print(c)
#编译结果：5

（二十一）string.splitlines([keepends])

  功能：按照行（’\r’,’\r\n’,’\n’）分隔，返回一个包含各行作为元素的列表
  参数：keepends默认False 不包含换行符
     keepends == True 会保留换行符

str40 = '''you reap what you sow
no pains no gains
You never know your luck
'''
print(str40.splitlines())
#编译结果：['you reap what you sow', 'no pains no gains', 'You never know your luck']

（二十二）string.join(seq)

  功能：以指定的字符串分隔符，将seq中的所有元素组合成一个字符串

#join(seq)  以指定的字符串分隔符，将seq中的所有元素组合成
#一个字符串
list41 = ['You','never','know','your','luck']
str42 = "&^%$#".join(list41)
print(str42)
#编译结果：You&^%$#never&^%$#know&^%$#your&^%$#luck

（二十三）max()，min() ：字符串中最大、最小的元素（根据ASCII码比较）

str43 = "You never know your luck"
print(max(str43))#编译结果：y
print(min(str43))#输出空格

（二十四）string.replace(oldstr,newstr,count)

  功能：#用newstr替换oldstr,默认是全部替换。如果指定了count，那么只替换前count个

str44 = "You never never never know your luck"
str45 = str44.replace("never", "will")
print(str44)#编译结果：You never never never know your luck
print(str45)#编译结果：You will will will know your luck

（二十五）string.maketrans(intab, outtab)与str.translate(table[, deletechars])

maketrans()
  功能：创建一个字符串的映射表
  参数：intab – 字符串中要替代的字符组成的字符串。
     outtab – 相应的映射字符的字符串。
translate()
  功能：根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中
  参数：table – 翻译表，翻译表是通过maketrans方法转换而来。
     deletechars – 字符串中要过滤的字符列表。

#          要转换的字符串,目标字符串
t46 = str.maketrans("ou", "65")
#将o  u 映射成 6  5
#o--6  u--5
print(t46)                          #编译结果：{111: 54, 117: 53}
str47 = "You never know your luck"
str48 = str47.translate(t46)
print(str48)                        #编译结果：Y65 never kn6w y65r l5ck

（二十六）string.startswith(str,start=0, end=len(str))

  功能：在给定的范围内判断是否是以给定的字符串开头，如果没有指定范围，默认整个字符串

str49 = "You never know your luck"
print(str49.startswith("You", 5, 16))#5-16范围内不是以You开头
#编译结果：False

（二十七）endswith(str, start=0, end=len(str))

  功能：在给定的范围内判断是否是以给定的字符串结尾，如果没有指定范围，默认整个字符串

str50 = "You never know your luck"
print(str50.endswith("luck"))#是以luck结尾
#编译结果：True

（二十八）string.encode(encoding=“utf-8”, errors=“strict”)与string.decode(encoding=‘utf-8’,errors=‘strict’)

encode
  功能：以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
decode
  功能：以 encoding 指定的编码格式解码字符串。默认编码为字符串编码。
  参数：
    encoding – 要使用的编码，如"utf-8"。
    errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’,   ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。

#编码
str51 = "You never know your luck"
data52 = str51.encode("utf-8")
print(data52)
#编译结果：b'You never know your luck'

#解码  注意：要与编码时的编码格式一致
str53 = data52.decode("utf-8")
print(str53)
#编译结果：You never know your luck

我们看下面的一段程序

str51 = "You never know your luck滴滴"
#ignore忽略错误
data52 = str51.encode("utf-8","ignore")
print(data52) 
#编译结果：b'You never know your luck\xe6\xbb\xb4\xe6\xbb\xb4'

#解码  
str53 = data52.decode("gbk","ignore")
print(str53) 
#编译结果：You never know your luck婊存淮

  我们在编码和解码时使用的编码格式不同，虽然我们使用ignore在编译时不会报错，但是解码后的结果和编码前的不一样了，所以我们在写程序时解码要与编码时的编码格式一致。

（二十九）string.isalpha()

  功能：如果字符串中至少有一个字符，且所有的字符都是字母返回True,否则返回False。

str54 = "Youneverknowyourluck"
print(str54.isalpha()) 
#编译结果：True

（三十）string.isalnum()

  功能：如果字符串中至少有一个字符且所有的字符都是字母或数字，返回True,否则返回False。

str55 = "123"
print(str55.isalnum()) 
#编译结果：True

（三十一）string.isupper()

  功能：如果字符串中至少有一个英文字符且所有的字符都是大写的英文字母返回True,否则返回False。

print("ABC".isupper())#True
print("ABCa".isupper())#False
print("ABC1".isupper())#True
print("ABC#".isupper())#True

（三十二）string.islower()

  功能：如果字符串中至少有一个英文字符且所有的字符都是小写的英文字母返回True,否则返回False。

print("abc".islower())#True
print("abcA".islower())#False
print("1".islower())#False
print("abc1".islower())#True
print("abc#".islower())#True

（三十三）string.istitle()

  功能：如果字符串是标题化的返回True,否则返回False（标题化:单词的首字母大写）

print("You Never".istitle())#True
print("You never".istitle())#False
print("you never".istitle())#False

（三十四）string.isdigit()，string.isnumeric()

  功能：如果字符串中只包含数字字符返回True，否则返回False

print("123".isdigit())#True
print("123a".isdigit())#False

print("123".isnumeric())#True
print("123a".isnumeric())#False

（三十五）string.isdecimal()

  功能：字符串中只包含十进制字符返回True，否则返回False

print("123".isdecimal())#True
print("123z".isdecimal())#False

（三十六）string.isspace()

  功能：如果字符串中只包含空格则返回True,否则返回False

print(" ".isspace())#True
print("     ".isspace())#True
print("\t".isspace())#True  这个字符串不是\t 是四个空格
print("\n".isspace())#True
print("\r".isspace())#True
print("\f".isspace())#True

五、while语句

  while表达式：
     语句

（一）while语句的逻辑

  当程序执行到while语句时，首先计算“表达式”的值，如果“表达式”的值为假，那么结束整个while语句。如果“表达式”的值为真，则执行“语句”，执行完“语句”再去计算“表达式”的值。如果“表达式”的值为假，那么结束整个while语句。如果“表达式”的值还为真。如此循环往复，直到“表达式”的值为假才停止。

例子

1.

num = 1
while num <= 5:
    print(num)
    num += 1
'''
编译结果：
          	1
			2
			3
			4
			5
'''			

2.计算1+2+3+…+100

sum = 0
num = 1
while num <= 100:
    sum += num
    num += 1
print("sum = %d" % (sum))
#编译结果：sum = 5050

3.将字符串str = “no pains no gains”里的内容一个一个打印出来。

str = "no pains no gains"
index = 0
while index < len(str):         #  index < 16
    print("str[%d] = %s" % (index,str[index]))
    index += 1
'''
编译结果：
str[0] = n
str[1] = o
str[2] =  
str[3] = p
str[4] = a
str[5] = i
str[6] = n
str[7] = s
str[8] =  
str[9] = n
str[10] = o
str[11] =  
str[12] = g
str[13] = a
str[14] = i
str[15] = n
str[16] = s
'''

（二）使用else语句

格式：
while 表达式：
   语句1
else:
   语句2
逻辑：在条件语句（表达式）为False时，执行else中的“语句2”

例子

a = 1
while a <=3:
    print("you reap what you sow")
else:
    print("no pains no gains")

print("hello")