python基础数据类型----整数 ,

发布时间：2019-06-01 20:40:55编辑：auto阅读（1907）

    Python基础数据类型

    • bool str int 三者之间的转换
    • str索引切片，常用操作方法
    • for循环（大量的练习题）

    1.基础数类型总览

    • 整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).
      • 10203 123 3340 int 主要用于计算+- * / 等等
      • '今天吃了没？' str 存储少量的数据，并进行相应的操作。str1 + str2， str *int ， 索引，切片， 其他操作方法
      • True False bool 判断真假
      • [12, True, 'alex', [1,2,3 ]] list 存储大量有序数据。列表内部数据可任意改动
      • (12, True, 'alex', [1,2,3 ]) tuple 存储大量的数据，元组不可改变里面的元素。只读，不能更改。
      • {'name': '太白金星'} dict 字典存储大量的关联性比较强的数据，查询速度非常快。
      • set 集合

    2.数字int

    • 十进制二进制转换

#二进制转换成十进制
0001 1010     ------>   26

b = 1 * 2**4 + 1 * 2**3 + 0 * 2**2 + 1 * 2**1 + 0 * 2**0
print(b)  # 26


#十进制整数转换成二进制整数 
42  -----> 0010 1010    除2取余，逆序排列

#十进制小数转换成二进制小数  
乘2取整，顺序排列：用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止。
0.625 = (0.101)B
0.625 * 2 = 1.25 ---->1
0.25 * 2 =0.5    ---->0
0.50 * 2 =1.0    ---->1

    • bit_lenth 十进制转化成二进制的有效长度【bit_length()计算整数在内存中占用的二进制码的长度.】

      # bit_lenth 有效的二进制的长度
i = 4
print(i.bit_length())  # 3
i = 5
print(i.bit_length())  # 3
i = 42
print(i.bit_length())  # 4

    3.布尔值bool：True False

    • bool str int 三者之间的转换

      数据类型之间的转换：
##### bool  <---> int #######
#bool-->int  :True    1   False     0
print(int(True))  # 1
print(int(False))  # 0   

#int-->bool  :非零即True ,0 为 False
i = 0
print(bool(i))

【重点】##### str   <--->   int  #####
# str ---> int  : 只能是纯数字组成的字符串可以转化成数字类型
s1 = '1088'     
print(int(s1))  # 字符串引号内必须是数字组成 

print(int('   22   '))#22  仅由数字和空白组成的字符串，通过int进行数据类型转换时，自动去除空格
print(int('   \n   22\t'))#22  仅由数字和空白组成的字符串，通过int进行数据类型转换时，自动去除空格

#应用：两个整数相加
while 1:
    content = input('请输入内容：')
    l1 = content.split('+')
    result = int(l1[0]) + int(l1[1])
    print(result)


# int ----> str  所有数字都能转化成字符串
i = 100
print(str(i),type(str(i)))

【重点】###### str <---> bool ##### 
# str--->bool :非空即True
s1 = ' '  #空格，不是空
print(bool(s1))  #True

s1 = ''  # 空字符串,为False
print(bool(s1))   #False

# bool  ---> str  无意义
print(str(True), type(str(True)))  # 运行结果：True <class 'str'>
      • 应用：
      s = input('输入内容')   #input输入的为字符串类型
if s:                #（字符串作为布尔值进行判断）
    print('有内容')
else:
    print('没有输入任何内容')
#直接回车，显示“没有输入任何内容”
#先空格，再回车，显示“有内容”

    4.字符串str（重点）

    • Python中凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。

    • 索引：索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推

    • 切片：切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串

    • 对字符串进行索引和切片，出来的数据都是字符串类型。

    • 常用操作方法:字符串的常用操作方法,不会对原字符串进行任何操作，都是产生一个新的字符串

      • 索引切片步长
      #字符从左至右有顺序，依次为0，1，2....。从右往左以次为-1，-2，-3，....
s1 = 'python全栈22期'

# 按照索引取值，每次取一个字符。索引即下标index
s2 = s1[0] 
print(s2)          #p
print(s2,type(s2)) #p <class 'str'>
s3 = s1[2]
print(s3)          #t
s4 = s1[-1]
print(s4)          #期

# 按照切片取值。按照切片取值，原则：顾头不顾腚
s5 = s1[0:6]
s5 = s1[:6]  #从开头开始取，0可以默认不写
print(s5)   #python
s6 = s1[6:]
print(s6)   #全栈22期
print（s1[:-1] #python全栈22 
               #-1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到'期'元素

# 切片步长
s7 = s1[:5:2]  #加步长
print(s7)     #pto
print(s1[:])  ##开头到最后，python全栈22期

# 倒序：
s8 = s1[-1:-6:-1]  ##反向加步长
print(s8)     #期22栈全

# 倒序全部取出来
s9 = s1[-1::-1]
print(s9)    #期22栈全nohtyp

s9 = s1[::-1]
print(s9)    #期22栈全nohtyp

s9 = s1[-1:0:-1]  #错误
print(s9)    #期22栈全nohty  没有字母p 


 按索引：s1[index]   注释：index下标
 按照切片取值： s1[start_index: end_index+1]
 按照切片步长取值： s1[start_index: end_index+1: step]
 反向按照切片步长取值： s1[start_index: end_index后延一位: step]

    • 练习题

      '''
有字符串s = "123a4b5c"
通过对s切片形成新的字符串s1,s1 = "123"
通过对s切片形成新的字符串s2,s2 = "a4b"
通过对s切片形成新的字符串s3,s3 = "1345"
通过对s切片形成字符串s4,s4 = "2ab"
通过对s切片形成字符串s5,s5 = "c"
通过对s切片形成字符串s6,s6 = "ba2"
'''

s = "123a4b5c"
s1 = s[0:3]
s1 = s[:3]
print(s1)
s2 = s[3:6]
s2 = s[-5:-2]
print(s2)
s3 = s[0:-1:2]
print(s3)
s4 = s[1:6:2]
print(s4)
s5 = s[-1]
print(s5)
s6 = s[-3:0:-2]
print(s6)
      • 常用操作方法【重点】
      字符串的常用操作方法,不会对原字符串进行任何操作，都是产生一个新的字符串


upper lower
#例
s = 'taiBAifdsa'
s1 = s.upper()   #字符串s中字符全部大写（不会对原字符串进行任何操作，都是产生一个新的字符串
print(s1,type(s1))  #TAIBAICBR
s2 = s.lower()    #字符串s中字符全部小写
print(s2,type(s2))   #taibaicbr

# 应用：
username = input('用户名')
password = input('密码')
code = 'QweA'
print(code)
your_code = input('请输入验证码：不区分大小写')
if your_code.upper() == code.upper():
    if username == '太白' and password == '123':
        print('登录成功')
    else:
        print('用户名密码错误')
else:
    print('验证码错误')



startswith    endswith
#startswith 判断是否以...开头
s = 'taiBAifdsa'
print(s.startswith('t'))        #True ***【重点】 判断是否以单个字符开头
print(s.startswith('taiBAi'))   #True ***【重点】 判断是否以多个字符开头
print(s.startswith(' '))        #False 判断是否以空格开头

#endswith 判断是否以...结尾
s = 'taiBAIcBr'
s1 = s.endswith('t')
print(s1)  #False，返回的是布尔值
s2 = s.endswith('Br')
print(s2)  #True

# 了解
s = 'taiBAifdsa'
print(s.startswith('B',3,6))   #True   括号内的字符串必须加引号'B'
                               #切片，顾头不顾腚。判断'BAi'是否以B开头。下标3，6，不包括6对应的f。
s = 'taiBAifdsa'
print(s.endswith('f',3,6))    #False



replace(old,new,count)
#讲
msg = 'alex 很nb,alex是老男孩教育的创始人之一，alex长得很帅'
msg1 = msg.replace('alex','太白')  # 默认全部替换,用'太白'替换'alex'
msg1 = msg.replace('alex','太白',2)   #用'太白'替换'alex',2表示只替换前两个字符串
print(msg)  #alex 很nb,alex是老男孩教育的创始人之一，alex长得很帅
print(msg1) #太白 很nb,太白是老男孩教育的创始人之一，alex长得很帅

#自
msg = '小明生病了，小明没去上学，小明在家休息'
msg1 = msg.replace('小明','小红')
print(msg1)  #小红生病了，小红没去上学，小红在家休息
msg2 = msg.replace('小明','小红',2)
print(msg2)  #小红生病了，小红没去上学，小明在家休息

#自：比如某个字母小写变大写，大写边小写
s = ' qw sertyu eqtrti '
s1 = s.replace('t','T',2)
print(s1)# qw serTyu eqTrti



strip:去除空白，如空格，\t制表符， \n换行符。
# \n(换行符-将光标移动到下一行的开头)
# \t(水平制表符-将光标向右移动一个制表符位)

#默认去除字符串两边的空格，换行符，制表符
s4 = '  \n太白\t'
print(s4)
s5 = s4.strip()
print(s5)
#修改测试
s4 = '  \n太 白 tai \tbai\t'
print(s4)
s5 = s4.strip()
print(s5)#太 白 tai     bai   #只能去掉两边的空白，内部的去不掉



name='*barr*y**'
print(name.strip('*'))  # barry
print(name.lstrip('*'))  # barry**
print(name.rstrip('*'))  # *barry
#修改测试
name='*barr*y**'
print(name.strip('*'))  # barr*y   #只把两边的*去掉了，内部的*去不了。
print(name.lstrip('*'))  # barr*y**
print(name.rstrip('*'))  # *barr*y

# 了解：可以去除指定的字符
s4 = 'rre太r白qsd'
s5 = s4.strip('qrsed')  #括号内字符串加引号,字符顺序无所谓
print(s5)  #太r白     #只能去两头的对应字符


split  【非常重要】以什么分割，最终形成一个列表，此列表不含有这个分割的元素。
# str ---> list  字符串类型转换为列表类型，- 默认按照空格分隔，可以指定分隔符。

# 默认按照空字符串（空格，换行，制表符）分隔，返回一个列表
s6 = '太白 女神 吴超'
l = s6.split()
print(l)  #['太白', '女神', '吴超']

# 指定分隔符
s6 = '太白:女神:吴超'
l = s6.split(':')   #  :作为分隔符
print(l)  #['太白', '女神', '吴超']

ret9 = 'title,Tilte,atre,'.split('t')  # t作为分隔符
print(ret9)  #['', 'i', 'le,Til', 'e,a', 're,']  ''空字符

#rsplit  
ret91 = 'title,Tilte,atre,'.rsplit('t',2)  
print(ret91)#['title,Til', 'e,a', 're,']

# 了解：
s6 = ':barry:nvshen:wu'
print(s6.split(':'))    #['', 'barry', 'nvshen', 'wu']  注：''空字符串
print(s6.split(":",2))  #['', 'barry', 'nvshen:wu']  #2表示前两个：有效

#自-实验
s1 = ' .haha.heihei.hehe.123'
s2 = s1.split('.')   # .作为分隔符
s3 = s1.split('.',3)
print(s2)  #[' ', 'haha', 'heihei', 'hehe', '123']  注：' ' 引号内为空格
print(s3)  #[' ', 'haha', 'heihei', 'hehe.123']



join（iterable）：联合，连接，可以操作任何可迭代对象（可迭代：这个数据由多个元素组成，如字符串，列表），     

s1 = 'alex'
s2 = '+'.join(s1)   #'设置连接符'.join(iterable)  iterable可迭代  用+作为连接符
print(s2）   #   a+l+e+x（字符串类型）
print(s2,type(s2))  # a+l+e+x <class 'str'>

#list ---> str  前提：列表里面的元素必须都是str类型才行
l1 = ['太白', '女神', '吴超'] 
s3 = ':'.join(l1)   #用：作为连接符
print(s3)   #  太白:女神:吴超(字符串类型)
print(s3,type(s3)) #太白:女神:吴超 <class 'str'>
s3 = ' '.join(l1)   #用空格作为连接符



count
#count数出字符串中的元素出现的个数。
s8 = 'sdfsdagsfdagfdhgfhgfhfghfdagsaa'
print(s8.count('a'))  #5，5是数字类型
s9 = s8.count("a",0,11) # 可切片，索引0,11不包含11
print(s9)             #2


format: 格式化输出
# 第一种用法：
msg = '我叫{}今年{}性别{}'.format('大壮',25,'男')
# 第二种用法：
msg = '我叫{0}今年{1}性别{2}我依然叫{0}'.format('大壮', 25,'男')
print(msg)
# 第三种用法：
a = 100
msg = '我叫{name}今年{age}性别{sex}'.format(age=a,sex='男',name='大壮')  #此处format（）内可以不按顺序
print(msg)


is 系列： 返回布尔值
#name = '100①'
name = 'taibai123'
print(name.isalnum()) #字符串由字母或数字组成   True
print(name.isalpha()) #字符串只由字母组成    False

s1 = '123'
print(s1.isdecimal()) #字符串只由十进制组成    True
print(s1.isdigit())  # 如果字符串中的所有字符都是数字，并且至少有一个字符，则返回True。  True

s1 = b'123'
# print(s1.isdecimal()) #报错：AttributeError: 'bytes' object has no attribute 'isdecimal'
print(s1.isdigit())  # 如果字符串中的所有字符都是数字，并且至少有一个字符，则返回True。  True。


#应用
s1 = input('请输入您的金额：')
if s1.isdecimal():
     print(int(s1))
else:
     print('输入有误')

补充：
#寻找字符串中的元素是否存在
  find :通过元素找索引，找到第一个就返回，找不到 返回-1
  index:通过元素找索引，找到第一个就返回，找不到 报错

a4 = "dkfjdkfasf54"
ret1 = a4.find("fjdk",1,6)
print(ret1)  #2 返回的找到的元素的索引，如果找不到返回-1
ret2 = a4.index("fjdk",2,6)
print(ret2) #2 返回的找到的元素的索引，找不到报错。
ret2 = a4.index("fjdk",4,6)
print(ret2)#报错

#capitalize,swapcase,title
name='taiBAIhi123'
print(name.capitalize()) #Taibaihi123   首字母大写，其余变小写
print(name.swapcase()) #TAIbaiHI123     大小写翻转
msg='taibai say hi'
print(msg.title()) #Taibai Say Hi  每个单词的首字母大写

# 内同居中，总长度，空白处填充
ret3 = a4.center(22,"*")
print(ret3)#*****dkfjdkfasf54*****

#python内置函数
1.len()
#len（）:获取可迭代对象的元素总个数，是内置函数。不是字符串专用的

2.ord()
#以一个字符（长度为1的字符串）作为参数，返回单个字符的 ASCII 数值(0-255)，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
print(ord('a'))#97
print(ord('A'))#65

3.chr()
#chr()函数是输入一个整数（0-255），返回其对应的ASCII字符
print(chr(65))#A
print(chr(97))#a

    5.for循环:有限循环

    s1 = '老男孩edu'
print('老' in s1)   #True   成员运算符
print('老男' in s1)   #True
print('老ed' in s1)   #False
print('老ed' not in s1)  #True

s1 = '老男孩教育最好的讲师：太白'

输出：
'''
老      s1[0]
男      s1[1]
孩      s1[2]
教      s1[3]
育      ....
最
...
'''

s1 = '老男孩教育最好的讲师：太白'
print(len(s1))   #13

#while循环代码(利用while循环打印可迭代对象的每个元素)
s1 = '老男孩教育最好的讲师：太白'
index = 0
while index < len(s1):   # len（） :获取可迭代对象的元素总个数，是内置函数。不是字符串专用的
     print(s1[index])
     index += 1


# for 循环

'''
有限循环
for 变量 in iterable:
    pass
'''

#for循环代码
s1 = '老男孩教育最好的讲师：太白'
for i in s1:
     print(i)

        #
for i in s1:
    print(i)
    if i == '好':
        break

# break continue
# for else: while else:用法一样。

关键字：

上一篇： Python之双色球选购和三级菜单问题

下一篇： Python基础函数