目录

总览：数字型 字符型 布尔型

一 ：数字型

1. 定义

2. 类型转换

3 使用

二：字符型

1.定义

2.类型转换

3.内置方法【重点学习】

三： 字符串格式化输出

1. format()方法

2. f'' 方法

总览：数字型 字符型 布尔型

一 ：数字型

1. 定义

1 整数型 和浮点型的定义
age = 18 
salary = 3333.3 

2 查看其类型 
print(type(age)
print(type(salary) 

2. 类型转换

2.1 字符串转整型
age = '18'
print(int(age)) 

2.2 浮点型转整数
salary = 3333.3
print(int(age)) 

2.3 进制的转换,进制的转换使用是内置的函数方法
bin() # 二进制
oct() # 八进制
hex() # 十六进制 

age = 4 
print(bin(age)) 
# 0b100
print(oct(age))
# 0o4
print(hex(age))
# 0x4

#print() 打印函数会自动将 二进制 八进制 十六进制转换为 十进制数来显示
print(0b100,0o4,0x4)
# 4 4 4 
#也可以使用int() 方法来将其他进制转换为十进制数来显示,要求被转换的类型按字符串类型显示
print(int('0b100',2)) #后面是2是指明其原先的进制
print(int('0o4',8))
print(int('0x4',16))
# 4 4 4 

3 使用

数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法

二：字符型

1.定义

# 1 字符串的定义 使用单引号 双引号 三引号都可以 

name1 = '张三'
name2 = "李四"
name3 = '''王五'''

2.类型转换

# 2 字符串的转换，任意类型都可以转换为字符串

print(str([1,2,3]))  # 列表转换为字符串
print(str((1,2,)))   #元组转换为字符串
print(str({'k1':1,'k2':2})) #字典转换为字符串
print(str({1,2,3,4}))  #集合转换为字符串 

3.内置方法【重点学习】

2.1 基本用法

str1 = 'hello python!'
#1 正向索引 负向索引

print(str1[0],str1[-1])

#2 字符串是不可变类型，其值不可以改变 

#3 字符串的长度，计算是单个字符的个数，包括空格等不可见字符
len(str1)

#4 字符串的遍历 
for i in str1:
    print(i)

#5 成员运算符 in ,not in
 print('alex' in 'alex is sb') -> True   

2.2 内置切片

s1='012345'

1 简单用法
s2 = s1[0:5] #将s1的从索引0到索引5都赋值给s2，
注意1 字符串是不可变类型，其是将s1值赋值给s2,
注意2 [] 中括号内都是索引 
注意3 切片是左包右不包，也就是说[0:5] 只有01234 ，5不在其中国。 

2 指定步长2
s2 = s1[0:5:2] 
#024

3 默认情况如果步长不写，其值为+1 ，当步长为正值时，可以想象为从左到右的向量。
如果步长为负数时，可以想象为从右到左的向量，为什么强调方向？
因为如果是
s1[0:5:-1] #此时的结果是空，因为步长为负数，也就是从右到左，此时的值应该是从大到笑，但是此时却是0:5 
同理：
s1[5:0:1] #此时的结果也是空 

4 起始位置 到 结束位置构成了一个方向的向量，步长为正 其方向是从左到右，步长为负，其方向是从右到左。
当起始位置-结束位置的方向 和步长的方向不一致时会发生什么？

s1='012345'
s1[5:-1:-1] #此时值是多少？ 
>>>
s1[5:-2:-1] #此时的值又是多少
>>>5 

s1[1:1:1] #此时的值又是多少
>>>

思考：以上的所有的方法，通过[0:len(s1)]的方法能取到完整的字符串，但是如何反向取到完整的字符串了？

5 特殊用法
s1[::] 正向取所有的字符
s1[::-1]方向取所有的字符




总结：
1 当步长的方向和起始位置-结束位置方向不一致时，其值为空，因为目标不可达.
2 当起始位置=结束位置时，其值为空
3 中括号内都是索引号并非是其值

练习
s1 = '012345'
print(s1[0:len(s1)])    #012345
print(s1[4:0:-1])       #4321 
print(s1[5:-3:-1])      #54  #
print(s1[3:-1:-1])      #此时从3到-1 需要向右走，但是-1 又是向左走因此无法到达，
print(s1[3:-2:-1])      #同理3到-2也是需要向右走，但是-1 是向左走是 为空
print(s1[3:-3:-1])      #从自身到自身也是空值
print(s1[1:1:1])        #从自身到自身也是空置。

 

 2.3 字符串的内置方法

• strip,split,join

#字符串的方法strip() 去除首尾指定的字符
#1 去除单个字符
s1 = '======================begin====================='
s1 =s1.strip('=')
print(s1) 
#>>> begin

#2 去除首尾的空格默认 
s1 = '    hello pthon     '
s1 = s1.strip()
print(s1)
#>>>hello pthon 

#3 去除多个字符的,strip('字符串') 可以想象成字符串的集合，集合里面的字符，在首尾出现的都去掉，
#直到第一个非集合里面的字符

s1 = 'xxxx&*())((hello python %#######'
s1 = s1.strip('x&*%()#')
print(s1)
#>>>hello python

#split() 将字符串按指定的分割符分割成一个列表。
#1 默认按空格来进行分割
s1 ='hello pthon'.split()
print(s1)
#>>>['hello', 'pthon']

#2 指定分割符 
s2 = 'hello pthon'.split('o')
print(s2)
#>>>['hell', ' pth', 'n']
#此种写法等同与上一种
s2 = 'hello pthon'.split(sep='o ')
print(s2)
#>>>['hell', 'pthon']
#注意 split() 只能指定一种分割符，如果分隔符没有匹配到将整个字符串作为列表的一个元素。

#join() 方法 将一个可迭代对象的元素按指定的字符串来连接起来 。注意此时的元素都必须是字符串，否正会报异常
#此时的可迭代对象 可以是列表 字典 range 字符串
list1 = ['1','2','3','4']
dict1 = {'k1':1,'k2':2}
s1 = 'hello'

#注意该方法是字符串的方法而非列表的处理方法

print(":".join(list1))
#>>>1:2:3:4
print(":".join(dict1))
#>>>k1:k2
print(":".join(s1))
#>>>h:e:l:l:o
#print(":".join(range(4))) #此时会报错因为需要元素都是字符串，range对象的元素是数字。


#字符串和join 互相转换 

s1 = 'h e l l o'
list2 =s1.split()
print(list2) # -> ['h', 'e', 'l', 'l', 'o']
print(" ".join(list2)) # -> h e l l o

• strip,lstrip,rstrip

s1 = '=============begin============='
print(s1.strip('=')) #修剪两边的=
print(s1.lstrip('=')) #修剪到左边的=
print(s1.rstrip('=')) #修剪到右边的=
'''
begin
begin=============
=============begin
'''

• lower,upper

lower() #将全部大写字母转换为小写字母
upper() 将全部小写字母转换为大写字母

s1 = 'Hello python'
print(s1.upper())  #HELLO PYTHON
print(s1.lower())  #hello python

• startwith,endwith

#endswith 判断是否以xx 为结束符
#通过此方法来找出指定结尾的文件。
#将要要的指定类型的文件赋值给一个元组，在调用字符串的endswith()方法
file1 = '1.doc'
file2 = '2.txt'
file3 = '3.exe'

l1 = [file1,file2,file3]
tuple1 = ('.doc','.exe','.txt',)

#1 指定字符串结尾的
print(file1.endswith('doc')) # True 


#2 还可以使用一个元组，元组内存放多个字符串，只要是该字符串结尾的都返回True 
for i in range(len(l1)):
      print(l1[i].endswith(tuple1),end=' ')

#>>>True True True

#同理startswith() 找出以xx 开头的文件,单同时寻找多个字符串时，可以用元组，但是元组的元素类型必须是字符串。
t1 = ('1','2','3',) #元组的元素类型必须是字符串
for i in range(len(l1)):
      print(l1[i].startswith(t1))

#True
#True
#True

•  replace()

#replace() 第一个参数旧字符 ，第二个参数新的字符 ，第三个参数要替换的次数 默认不写表示全部替换
print('hello ptyhon'.replace('o','0'))
#hell0 ptyh0n
print('hello ptyhon'.replace('o','0',1))
#hell0 ptyhon

• is系列 如isdigit() isalpha() isidentifier() isalnum()

'xxxx'.isalnum() #是否是字母和数字的组合，纯数字和字母都可以
'xxxx'.isalpha() #是否是字母
'xxxx'.isdigit() #是否只是数字
'xxxx'.islower() #是否都是小写
'xxxx'.isupper() #是否都是大写
'xxxx'.istitle() #是否都是每个单词的首字符都大写
'xxxx'.isspace() # 是否都是空格
'xxxx'.isidentifier() # 是否都是标识符，标识符分两种，一种是 python 的关键字 is in for range list 等 
#另一种是字母数字和下划线组成，但是不能是以数字开头的

数字型 
num1 = b'123'  # 只有isdigit()方法 没有 isnumeric() 方法
num2 = u'123'  #python3 中 带u 的和 '123' 字符串中的数字是一样的 
               #print((u'123') == '123')  ===> True ;
               #print((u'123') == 123) ====> False 
num3 = '四'
num4 = 'Ⅳ'

#只有num1 num2 idgidit() 是能识别的。 num2 num3 num4 isnumeric() 是可以识别的。

print(num1.isdigit())  # True
print('-------------')
print(num2.isdigit())   #True 
print(num2.isnumeric()) #True
print('-------------')
print(num3.isdigit()) #False
print(num3.isnumeric()) #True
print('-------------')
print(num4.isdigit())  #False
print(num4.isnumeric()) #True 

三： 字符串格式化输出

1. format()方法

d1 = {"name":"zhangsan","age":19 }
age = 19

#在字符串中如何使用变量？ 直接在字符串中使用变量会被字符串直接识别为普通字符串。
#format() 方法中，使用形参来，而在括号内表明 形参对应的实参，此时的实参是可以使用变量的。
#方式1 
print("my name is {} , my age is {} ".format(d1["name"],d1["age"]))  

# 方式二 {name} 为字符串内的变量，当为{} 非索引编号时，为key value 类型。
print("my name is {name} , my age is {age}".format(name = d1["name"],age = d1["age"])) 

#方式三 解压包来赋值，注意此时需要使用**来解压包。此时的类型只是是map 类型的，如字典 ，不能是列表 ，字符串的类型。
print("my name is {name} , my age is {age}".format(**d1)) 

2. f'' 方法 只在python3.6之后才能使用

#在 f'' 方式中则{} 来直接使用变量
# #f'' 好处1 直接使用变量
# print(f'{age}')
# print(f'{{age}}') #显示是{age} 非其值
# print(f'{{{age}}}') #显示{19}
# # f'{运算}' f'{函数}' 都可以直接使用。