python初学一（字符串str的处理方式）

• 1、字符串是不可变类型，没有类似list 中的pop 删除函数
• 2、字符串是不可变类型，字符串函数操作后原字符串的内容不会发生改变，函数的返回值是修改后的值。
•             例：

一，input()输入的用法： 

•        特点：① 变量接受的值是     字符串类型  ，如果输入  整型  进行数学运算   一定要用int（）将  str类型 转化 int类型 。
•                   ② input（）表示将键盘输入值传给变量，程序一直等待键盘输入，input()内部添加输入提示信息：

a = input('请输入您的姓名：\n') 
# input表示键盘输入，程序将一直等待键盘输入，input可以添加提示信息。  变量是   字符串类型。
# \n  ------ 换行
print(a)

--------------------------------------------------------------------------
name = input('请输入你的姓名: \n')
age = input('请输入你的年龄: \n')
print('您的姓名是:',name,'年龄是:',age,'岁')    # >>>>>>>>>>>>>>>> print 多个变量时,系统默认添加一个 空格
print('您的姓名是:'+name,'年龄是:'+age+'岁') # >>>>>>>>>>> 用字符串拼接的方式,去除 默认的空格

二、字符串的格式化输出方式：

      1、第一种方式： %s

                 常用的格式符号:%[(name)][flags][width].[precision]typecode

  （1）用法范围为：％s>％f>％d，

•          特点： 即％s可以替换％f与％d，％f可以替换％d，反之报错如：

name,age = '张松会死',20
dict1 = {'name':'张松会死','age':20,}
print('%s的年龄是%d' %(name,age))
print('%s的年龄是%s' %(name,age))
print('%s的年龄是%f' %(name,age))           #默认6位
print('%s的年龄是%.f' %(name,age))           #没有小数
print('%s的年龄是%.2f' %(name,age))          #两位小数
print('%20s的年龄是%.f' %(name,age))          空出20个字符
print('%.2s的年龄是%.f' %(name,age))          取几个字符（注意中文字符与字节的区别）
print('%(name)s的年龄是%(age).f' %dict1)     #   利用  字典 的 key  进行 字典 传值
    

                

     （2）综合数据内部元素格式化：

•          特点：%s 可以用于  key是str 的 dict类型数据  格式化，不能用与list格式化。

                          列表不能用%s 格式化内部元素
list1 = ['can add post','can delete post','can ban user']
print('管理员的权限为: %()s %()s %()s' %(list1))
print('管理员的权限为: %s %s %s' %(*list1))    两种情况均会报错。可以用  str.format 的方式


                  字典可以用%s格式化内部元素（key必须是字符串类型），不可用**dict的方式
dict1 = {'1':'can add post',
         '2':'can delete post',
         '3':'can ban user',
}
print('管理员的权限为: %(1)s %(2)s %(3)s' %dict1)    # 管理员的权限为: can add post can delete post can ban user
print('管理员的权限为: %(1)s %(1)s %(3)s' %dict1)    # 管理员的权限为: can add post can add post can ban user

  （3）%s  格式化时间的方法： 

                  print  时间等一系列格式输出：

print('%d-%d-%s %d：%d：%d' %(2018,11,'02',11,43,50))

                                  结果：      

    2、字符串内置函数 format 格式化：. format()

通过位置
time1 = '{}--{}--{} {}::{}::{}'.format(2018,11,'02',11,43,50)
print(time1)
time1 = '{4}--{5}--{3} {3}::{1}::{0}'.format(2018,11,'02',11,43,50)  #format 可以添加索引
print(time1)
列表传值    *args
list1 = ['can add post','can delete post','can ban user']
print('管理员的权限为: “{}”、“{}”、“{}”'.format(*list1))    一定要加 *  # 结果： 管理员的权限为: “can add post”、“can delete post”、“can ban user”
通过关键字
print('{名字}今天{动作}'.format(名字='陈某某',动作='拍视频'))#通过关键字
2 grade = {'name' : '陈某某', 'fenshu': '59'}
3 print('{name}电工考了{fenshu}'.format(**grade))#通过关键字，可用字典当关键字传入值时，在字典前加**即可

                   更多： https://www.cnblogs.com/chunlaipiupiupiu/p/7978669.html 

•            format函数：1、format函数是str内置函数，用法str.format()
•                                  2、format函数支持索引对应填值，默认从左到右一一对应。
•                                  3、format中的  { }  相当于 %s 。
•  

     3、str.join() :

              优点：不限定 列表的长度

               实例：https://blog.csdn.net/qq_16555103/article/details/83685961  ------- 第一节 

三、str的基本操作方式：

     1、索引：

•         特点： 字符串支持索引 【其他支持索引的数据类型：列表，元组（不可变，但可改变可变数据类型元素的 二维
•                     元素），字典（无序，需要用 键 索引）】

a = '1234a6789'
print(a[1])                   
print(a[2:5])           区间为  前闭后开 的区间 （相当于步长为1的切片）                

     2、系统函数len（ietr）：

                                求可迭代对象的长度，也可以计算 列表 元组 的元素个数

a = '123abc'
b = [1,2,3,'a']            
print(len(a),len(b))       #列表是元素个数，字符串是字符个数

    3、字符串拼接 与重复：

     （1）字符串的拼接： + 

a, b, c, d = '我们','是','中国人','20'

print('我们'+'是'+'中国人'+'20')           #数字需要是字符串格式
print(a+b+c+d)

     （2）字符串的重复 ：*

print("abc")
print("abc"*10)

     4、print 中 end=  的用法：

                end= 也可以  填充其他的字符，默认是换行（\n）。

print('a','b','c')         ------- 输出多个字符串或变量时,系统默认用 空格 拼接,即结果:a b c
print('a'+'b'+'c')         ------- 结果:   abc
===========================================================================================
print('a')        ---------- print 默认有一个换行符，即end='\n'
print('b')
print('c') 
========================================  注意上下区别
print('a',end='')
print('b',end='')
print('c',)

    

    5、str（）强转字符串： 

                      系统函数，强制转化为字符串。

                    

                     

                    注意：print 字符串去掉引号；list 变量外面多了 '  '，变成了 str 类型 ，str() 转化后需要用系统函数  eval（）

                               来提取字符串中的数据。 。

    6、切片：   

    （1）切片的使用方法：         

•                    特点：① 从  起始索引  开始取值，第二个值的索引为  起始+步长     
•                               ② 结果是一个 str 类型，可以用int（）转化：

• 要求，求出任一数字的百、十、个位
  num_str = str(345678)
  print(int(num_str[-3:]))  ------ 利用字符串切片切开后转化为数字

•                               ③ 索引为负数时表示倒着取值，即 -1 倒数第一 、 -2 倒数第二

     （2）切片的例子： 

a = 'abcdefghijkl'    
print(a[2:9])
print(a[2:9:2])       ------------  步长为 2
print(a[5:2:-2])      ------------  倒着取值
print(a[2:])          ------------  不写值取值到末尾
print(::)             ------------  选中所有，步长为 1
print(::2)            ------------  选中所有，步长为 2
print(a[2:-1])        ------------  -1 表示倒数第一个值，前闭后开，因此取不到最后一
print(a[-5:])         ------------  取任意字符串后五位字符

                                    

    7、字符串反转：利用切片 

str1 = input("请输入任意长度的字符串:\n")
str_reverse = str1[::-1]        --------------- 将字符串翻转,类似list中的 .reverse() 方法
print(str_reverse)              --------------- 例: 输入 abcde  输出 edcba 

四、str 内置函数： 

                 语法：str.func（）

    1、查找函数find、index：       

                     特点： 都是   返回索引值 ，它们只能查找 第一个 匹配元素的索引值

                        

print("hello world lo".find('lo'))    # 只会查找第一个，返回索引值，没有返回 -1
 #  答案  3
print("hello world lo".index('lo'))   # 只会查找第一个，返回索引值，没有  报错
 #  答案  3

   2、计数函数count：       

                  特点：有三个参数    

                        

a = 'abcdkoidkljjkcddddddddddd'
print(a.count('d'))
# 答案 13
print(a.count('d',0,len(a)))      #三个参数，后两个参数是 索引范围（前闭后开）
# 答案 13
print(a.count('d',0,len(a)-3))

   3、替换respace：       

                                                                              有三个参数   

                               

a = 'hello world hello'
print(a.replace('hello','HELLO'))     # 把xxx替换为XXX（前————后）
print(a.replace('hello','HELLO',1))    # 三个参数，最后一个参数为 count

                            

   4、分割split、partition：     

     （1）split 分割：

•                       特点： 两个参数，可以控制分割次数，分割之后得到一个  list ，该 list元素 不包括分隔符本身

• 

                   实例：

                  
str1 = 'hello world beijing！'
print(str1.split(' '))                 #用空格（1个）分割，单个元素，不包含该分隔符本身
str2 = 'hello   world beijing！'
print(str2.split(' '))                 #用空格（1个）分割，单个元素，分割符之间空集也可以做一个元素
str3 = 'hello   world beijing！'
print(str3.split('l'))                 
print(str3.split('l',2))                #  count 可以控制分割次数
print(str3.split(''))                   #   空集分隔符 报错

                      结果： 

   （2）partition：

•          特点：将字符串分割为固定的三部分，结果也是一个 tuple ，且 保留分隔符

                 实例：

                                                    

   5、控制字母大小写title： 

                            

                            

                          

   6、检查 首字符 开头/结尾startswith：

                                      注意： 返回值是bool值，可以用于  if /while  判断语句当中。

                            

   7、对齐just、center：

                                                默认填充空格，也填充其他字符

                          

str_01 = 'abc'
print(str_01.ljust(10))
print(str_01.ljust(10,'*'))              # just函数可以加 其他字符（类似 end =“”），默认空格
print(str_01.rjust(10))
print(str_01.rjust(10,'*'))
print(str_01.center(10))
print(str_01.center(10,'*'))

                       

   8、删除（strip）函数：

                                       默认删除空格，也删除其他字符

                        

   9、连接/拼接（join（）函数：

                                    str.join(iterable) ，本质是for循环str拼接，对象必须是可迭代的，得到的结果是字符串。

                                       str 》》list             用list（）系统函数      

                                     list》》》str            ①list元素全是str时，用str.join(),其中str为 '' 。

                                                                      ②list元素不全是str时，用for循环拼接 。

                       

print('_'.join('abcd'))
print('_'.join(['4','a'])) 
print('_'.join([1,2,3,'4','a']))       # 结果报错 ，因为列表中有不是str的元素。

   10、判断字符串中字符的种类isalnum：      

                                isdecimal         判断是否只包含数字，与isdigit 区别是，不能判断特殊字符，例如：①。

num = '①'
print(num.isdigit())
print(num.isdecimal())

True
False

=================================================================================
# 题目: 判断字符串中   空格，字母，数字的个数
str1 = ' ahh hhj   jjjjn38 893 777 0 jj  '
num_alpha,num_digit,num_space = 0,0,0
for i in str1:
    if i.isspace():
        num_space += 1
    elif i.isdigit():
        num_digit += 1
    elif i.isalpha():
        num_alpha += 1
print("字母数量：%d 数字数量：%d 空格数量：%d" %(num_alpha,num_digit,num_space))

五、关键字：  in 、not in  迭代队像 

•                特点：① 在字符串中相当于用于if 语句中的 str.find(" ") 
•                           ② 其他迭代对象那个，类似list tuple dict 也可以用。
•                           ③ 判断结果是 bool 值，常常用于if 、while 的条件中

str1 = 'jklcknnlkmakkmmmlk'
print('a' in str1)      # 用于条件语句 ，结果为 bool 值 。