Python基础语法 第2节课（数据类型转换、运算符、字符串）

一、数据类型

1.数据类型有哪些

1.整型 int   2.浮点型 float    3.字符串 str     4.布尔型 bool     5.列表 list     6.元组 tuple      7.字典 dict

2.查看数据类型使用type()

eg:age = 18

　　type(age)

基本上会用内置函数instance()去判断类型

#查看数据类型
age = 18
gender = 'boy'
print(type(age))#int
print(isinstance(gender,str))#True
print(isinstance(gender,int))#False

3.数据类型的转换

int、float→str

　　str(123)  #'123'

       str(12.3) #'12.3'

int →float

　  float(123) #123.0

int、float、str→bool

　   bool(123) #True

　   bool(12.3) # True (非o就是True ,o/空就是False)

　　bool('1') #True

str→int /float （只有数字型字符串：才可以转换为int/float ）    

       str='123'   print(type(int(str)))   #int

　　str='123'   print(type(float(str)))   #float

float→int / str 

　　int(1.8)是1 ，直接留整数部分，小数部分舍去

❤重点讲解bool()

为0或者空，bool()都是false,

①print（bool(1)）#True

    print(bool(0)) #False

    print(bool(-1)) #True

②print(bool(''' ''')) #True  不是空字符串，三引号里面有空格，可以参照‘’‘ helloworld’‘’ != '''hello  world'''

   print(bool('''''')) #False

二、运算符

1.算术运算符 +  -  *  /  **  %  //

a = 2
b = 4
print(a + b)
print(b - a)
print(a * b)
print(b / a)  #2.0

加法+  可以实现字符串的拼接  列表的相加

#加法 字符串的拼接
str_1='hello'
str_2=' pyhton'
print(str_1 + str_2) #hello pyhton

#加法 列表的相加
list_1 = [1,2,3]
list_2 = [4,5,6]
print(list_1 + list_2) #[1, 2, 3, 4, 5, 6]

乘法*  可以实现对 字符串 列表 元组 字典 等的多次输出

str_2='pyhton'
list_2 = [4,5,6]
print(str_2 * 3) # pyhtonpyhtonpyhton
print(list_2 * 2) #[4, 5, 6, 4, 5, 6]

❤重点讲解除法 /

①除法：两个int型的数相除，结果会类型转化，为float

②除数不能为0

a = 10
b = 3
print(a/b)#3.3333

 幂运算：**

print(5**-2)#1/25

整除：//

整除，即只留商，舍去余数

print(25/2)#12,

模运算（取余运算）：%

print（25/2）#1 返回结果是余数

print（5/3）#2

 模运算运用：

经常用来判断奇偶性，余数为0是偶数，余数为1是奇数

2.赋值运算符

变量的定义就是典型的赋值运算

a = 5 #将5赋值给变量 
x += 1 #x = x + 1
y -= 4 #y = y - 4

3.比较运算符 >    >=   <    <=   !=    ==  6种

即：比较左右两边的值的大小   ==     ！= ，返回的结果是bool(True False)

a = 5
b = 8
print(a > b) #False
print(a != b) #True
print('get' == 'GET')#  False   python区分大小写
print(False == 0) # True   python 0 等同于false  1 等同于True
print(False == [])# []空列表是false,但是不能等同于

4.逻辑运算符 and  or  not （结果对应True、False）

and（且）:同时为真，才是真（只要有一个是false,结果就是false,并且）

a = 5
b = 8
print(a > b and b < 10)#False
print(a < b and b < 10)#True

or (或)：有一个为真，就是真（全假才是假）

a = 5
b = 8
print(a > b or  b < 10)#True
print(a < b or b < 10)#True
print(a > b or b > 10)#False 全假才是假

not(非)：专门取非运算

print(not False)#True

分不清楚优先级，可以用括号 括起来

5.成员关系运算符 in、 not in （返回的结果是bool : True False）

c = 'vip members include lili,lucy,polo'
print('lili' in c)

list_3 = [1,2,3,['hello','python',4,5,6]]
print('python' in list_3[3])  #True 

6.优先级总结

以下从左到右：高到低

幂运算** → + -（正负号）→ 算术运算符 → 比较运算符 → 逻辑运算符

三 、字符串

1.什么是字符串

引号括起来的数据类型就是字符串（引号可以是单引号、双引号、三引号（单三引号、双三引号，没区别））

a = 'hello python'
print(a)
s_2 = "world"
s_3 = '''lemon'''
s_4 = """best"""
print(type(s_1))

三引号可以表示多行字符串

b = '''人之初，性本善
性相近，习相远
。。。。。
。。。。。'''
print(b)

灵活拷问1：

三引号什么时候用来做注释？什么时候用来做字符串？

代码后面需要用到的，就是字符串

不需要使用，用来解释代码的就是注释

 灵活拷问2：

1).引号嵌套的时候 单引号只能嵌套双引号 双引号只能嵌套单引号 三引号没有区别

2).三引号可以做多行注释的作用

3).三引号可以保持字符串的格式 双引号需要依赖连接符来连接换行（）

2.字符串的操作 增删改查

①什么是成员运算符  in 、 not in

c = 'vip members include lili,lucy,polo'
print('lili' in c)

②字符串的索引

  1）python字符串的取值原理：索引 字符串里面的每个字符都是有下标的，并且是从索引值0（位置1）开始的

  下标 == 索引值

  2）索引取值方向

  正序索引：从0开始

  反序索引:从-1开始（从尾巴开始索引）

  3）怎么取：字符串名[索引值]

str_1='python'
print(str_1[3]) #h
print(str_1[-2]) #o

 4)索引超出范围 会报错indexerror

str_1 = 'hello'
print(str_1[8])

报错：

print(str_1[8])
IndexError: string index out of range

③字符串的切片

切片操作：可以从字符串中获取子字符串（原字符串的一部分）

分片的定义：一对 方括号 起始偏移量start 终止偏移量end  可选的步长 step 来定义一个切片

格式：[start:end:step]

Start:开始的索引值

End:结束的索引值

Step：步长，取值之间的间隔  默认值是1（默认是1的时候，可以不写）

特点：取头不取尾

举例：

s = 'hello python lemon'
print(s[::])#利用切片，实现字符串的复制
print(s[:18])
print(s[0:])
print(s[6:12])#12-6=6,有6个元素，6,7,8,9,10,11----→取头不取尾------正序
print(s[-12:-6])#-----反序

 

***字符串切片的常规操作***

1).[ : ]---利用切片来复制字符串，

2).[start : ] :从start提取到结尾

3).[ : end]: 从开头提取到end

4).[start : end] :从start取到end

❤提示：end-start 是正、是负

                step        是正 是负

判断切片能否正常输出结果：end-start  与step 符号（+ -）相同，就可以正常输出结果

                                                不相同：不报错，也没有输出结果

④字符串的格式化输出

方式1： %d  % s  % f  →占坑

print('''===个人信息===
address：%s
age:%d
salary:%f
''')

结果：

===个人信息===

address：%s

age:%d

salary:%f

上述没有具体格式输出，继续如下

print('''===个人信息===
address：%s
age:%d
salary:%f
''' % ('中央大街',18,23456.89))#按照对应的顺序复制，并做格式化输出

总结：

%S 这个坑位 可以放任意数据（字符串 整数 浮点）

%d %f 只能放数字

❤方式2: 字符串.format()

{ }:占坑

print('''===个人信息===
address：{}
age:{}
salary:{}
''' .format ('中央大街',18,23456.89))

结果：

===个人信息===

address：中央大街

age:18

salary:23456.89

format()：格式化输出，是Python2.6新增的格式化字符串的方法，把传统的%替换为{}来实现格式化输出（%：格式化操作符），相对于老版的%格式方法，有很多的优点。

优点：

1.format()不需要理会数据类型的问题；在%方法中%s只能替代字符串类型。

2.单个参数可以多次输出，参数顺序可以不相同。

3.填充方式十分灵活，对齐方式十分强大。

4.官方推荐使用的方式

format()后面的内容，填入大括号{}中（其中{}花括号表示replacement字段），format（）可以接受2种参数：位置参数、变量（关键字）参数，均传递到replacement字段。

按位置参数

1）.参数按照位置的顺序填充到字符串中，第一个参数是0，然后是1,2,3.......

>>> '{0} love {1}.{2}'.format('I','Fishc','com')  #前面的字符串调用format（）方法
'I love Fishc.com'

>>> '{1} love {0}.{2}'.format('I','Fishc','com')   #注意位置的替换
'Fishc love I.com'
>>> 

2）.不输入数字，直接按照顺序来填充

>>> '{} love {}.{}'.format('I','Fishc','com')
'I love Fishc.com'
>>> 

>>> #需要输出{}，可以用{{}}，即{}对自己转义
>>> '{{{0} love {1}}}'.format('I','you')
'{I love you}'
>>> 

>>> #一个位置参数可以使用2次
>>> '{{{1} love {0}.{1}}}'.format('fishc','I')
'{I love fishc.I}'
>>> 

按关键字参数

>>> #按照关键字参数，format()中要具体写明参数对应的值
>>> '{a} love {b}.{c}'.format('I','Fishc','com')
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    '{a} love {b}.{c}'.format('I','Fishc','com')
KeyError: 'a'
>>> '{a} love {b}.{c}'.format(a = 'I',b = 'Fishc',c = 'com')
'I love Fishc.com'
>>> 

综合位置参数、关键字参数（位置参数必须在关键字的前面，否则就是错误的）

>>> #综合 位置参数和关键字参数
>>> '{0} love {b}.{c}'.format('I',b = 'Fishc',c = 'com')
'I love Fishc.com'
>>> '{a} love {b}.{0}'.format(a = 'I',b = 'Fishc','com')
SyntaxError: positional argument follows keyword argument
>>> 

总结：

1)  { }的个数最好跟format后面括号里面的数据个数保持一致，如果不一致，{}的个数要比数据少

2)  Format()括号里面的数据是有索引的，也是从0开始，可以在{ }中指定取值的索引

3)  { }里面的要是给定索引值，必须全部都给索引值，不能有的给索引值，有的不给！！！！！！

4) 关键字索引：传参比较多的时候使用，是比较方便的

⑤、字符串中最常用的方法

1.find（）

解释：可以在一个较长的字符串中查找子串，返回子串所在位置的最左端索引（第一次出现的子串），如果没有找到则返回-1.

>>> 'I love Fishc.com'.find('com')
13
>>> title = 'I love fishc.com'
>>> title.find('fishc')
7
>>> title.find('hello')#找不到返回-1
-1
>>> 

注意：如果返回值是0，不是布尔型的0，而是在索引位置0找到了子串。例如：

>>> namestr = '$$$ Get Rich Now!$$$'
>>> namestr.find('$$$')
0
>>> 

index()函数查找，返回索引值

namestr = '$$$ Get Rich Now!$$$'
b = namestr.index('Get')
print(b)  #4

index()如果找不到，就会报错，（valueerror）

find()添加起始点跟结束点参数

>>> namestr
'$$$ Get Rich Now!$$$'
>>> namestr.find('!$$',1)#只提供起始点
16
>>> namestr.find('!$$')
16
>>> namestr.find('Rich',0,7) #索引位置起始点0，结束点位置7之间没有找到子串
-1
>>> 

 index(),find()都是找字符串的索引，注意区别：

1.相同点，都是查找索引值

2.不同点：在查找不对目标串的情况下，find()会返回-1，index()是报错-valueerror:substring not found

2.join()   字符串拼接的高级用法

解释：用来连接序列中的元素，是字符串中很重要的方法，是split()方法的逆方法。

注意：需要被连接的序列元素都必须是字符串!!

my_list = ['hello','python','lemon']
print(','.join(my_list))               #hello,python,lemon
print(type(','.join(my_list)))         #str 

dirs = '','user','bin','env'
print('C:' + '\'.join(dirs))   #C:userinenv

3.split()-----返回的结构是列表

解释：将字符串分割成序列，是join()的逆方法。

>>> 'This is a good idea!'.replace('is','ez')
'Thez ez a good idea!'
>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']>>> 'I love Fishc.com'.split(' ')
['I', 'love', 'Fishc.com']
>>> 

4.lower()

解释：返回字符串的小写字母版。

>>> title = 'I love Fishc.com'
>>> title.lower()
'i love fishc.com'
>>> 

5.replace()

解释：返回某字符串的所有匹配项均被替换之后得到的字符串。

>>> 'This is a good idea!'.replace('is','ez')   #可以理解为查找并替换
'Thez ez a good idea!'
>>> 

6.strip()

解释：（1）不加参数是除去字符串两侧的空格（不含字符串中间的空格）

　　　（2）加参数，是除去两侧的需要去掉的字符

>>> '      I love Fishc.com     '.strip()#不加参数
'I love Fishc.com'
>>> 

 加参数，只会去除字符串两侧的字符，对字符串中间没有影响.

7.count()  查找字符的次数

namelist = "I love you ,but you don't love me."
b = namelist.count('you')
print(b)  #2