数字int字符串str（深入学习）

数字int字符串str

查看一个对象的类

　　如：如查看对象变量a是什么类          用到函数type(),函数值是要查看的对象变量

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = type(a)
5 print(b)

　　如上就会输出：<type ‘str‘>    str是字符串类

　　查看一个对象类的类库

　　如上列，查到对象的类后，将类名称写在下面，按着ctrl键用鼠标点击这个类名称，就可以进入这个类的类库

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = type(a)
5 print(b)
6 str      #按着ctrl键用鼠标点击这个类名称，就可以进入这个类的类库

每一个类的类库里都有操作对象的各种功能

　　如：将小写字母转换大写字母

　　调用功能书写格式：（对象变量.功能函数)

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = a.upper()
5 print(b)

　 如上列a为字符串类的对象变量，upper()为字符串类的类库功能函数，b=a.upper() 打印b就将字符串转换成大写的了，输出ZJL

查看一个对象功能函数

　　如：上列　

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = a.upper()  #按着ctrl键用鼠标点击这个对象功能函数，就可以进入这个类的类库，找到对应的函数源码
5 print(b)

　　按着ctrl键用鼠标点击这个对象功能函数，就可以进入这个类的类库，找到对应的函数源码

查看一个对象的类库里具备哪些功能

　　如：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = dir(a)
5 print(b)
6 #运行后打印出对象类库的所有具备功能

　　这样就会得到：[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__doc__‘, ‘__eq__‘,等等

查看一个对象类库的所有功能与详情使用方法等

　　如：

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = help(type(a))
5 print(b)
6 #运行后打印出对象类库的所有具备功能

基本数据，对象类库里的常用功能

　　注意:对象类库里的功能函数，前后带有下划线的为特殊函数，是python程序的内置函数

　　如： _add_

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 a = 123
 4 b = 456
 5 print(a + b)
 6 #如上列，其实内部计算流程
 7 a = 123
 8 b = 456
 9 print(a.__add__(b))
10 #所以两个结果是一样的

　　1.整数，int

　　　　创建整数对象

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = 123
4 print(a)
5 #或者
6 b = int(123)
7 print(b)　　

所有以类名称加（）创建的一个类对象都是执行的类库里的（__init__ ）这个功能,初始化的意思

　　　　bit_length()　　　取二进制的最小表示位数（返回多少位）　　　　格式：a.bit_length()

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = 4 #100
4 b = a.bit_length()
5 print(b)#输出 3

　2.字符串，str

　　　　字符串常用功能：
　　　　移除空白
　　　　分割
　　　　长度
　　　　索引  
　　　　切片

　　创建字符串

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "你好"
4 print(a)
5 #或者
6 b = str("你好")
7 print(b)

　　　　capitalize()　　　　首字母大写　　　　格式：a.capitalize()

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = a.capitalize()
5 print(b)
6 #打印出首字母大写  Zjl

　　　　center(self, width, fillchar=None) 有参

　　　　""" （内容居中），width：总长度；fillchar：空白处填充内容，默认无 """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "zjl"
4 b = a.center(20,"*")
5 print(b)
6 #打印出    *****zjl******

　　　　count(self, sub, start=None, end=None) 有参

　　　　""" （查找字符在字符串属性次数），要查找的字符，查找范围开始位置，查找范围结束位置 """    （也就是查找一个或者多个字符，在一个字符串的出现次数）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = "小亮亮上山打虎碰见武二郎武二喝酒"
b = a.count("二", 0, 18)
print(b)
#打印出二字在字符串出现的次数 2

　　　注意一个中文字符，算3个字符，空格也算一个字符

　　　　endswith(self, suffix, start=None, end=None): 有参

　　　　返回：真或者假

　　　　""" （是否以 xxx 结束），要判断的字符，判断范围开始位置，判断范围结束位置 """

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = "nihzhongguo"
b = a.endswith("o")
print(b)
#判断字符串是否是o结尾打印出True
a = "nihozzzxiaoo"
b = a.endswith("o", 0, 5)
print(b)
#判断字符串从0到第5个位置是否是以o结尾 打印出False(顾头不顾尾)

　　　　expandtabs(self, tabsize=None)有参

　　　　""" （将tab转换成空格，默认一个tab转换成8个空格），自定义换成空格数 """

　　　　注意：\t表示tab键，如果在编辑器直接tab键，编辑器会自动转换成空格

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = "xiao\tliangliang"
b = a.expandtabs(9)
print(b)
#将tab键转换成9个空格打印出 xiao           liangliang
#注意如果不指定，默认是8个

　　　　find(self, sub, start=None, end=None)　　有参

　　　　""" (寻找字符在字符串里的位置)，要查找的字符，查找字符串起始位置，查找字符串结束位置，如果找到返回位置数，如果没找到，返回 -1 """　　

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = "xiaoliangliang"
b = a.find("l")
print(b)
#打印输出o在字符串里的位置 4
#如果没找到输出的是 -1

　　　　format(*args, **kwargs)有参

　　　 """ （替换字符串里的占位符），动态参数，将函数式编程时细说 """

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 a = "姓名 {0} 年龄 {1}"
 4 #{}站位符里面一般从0编号
 5 b = a.format("小亮亮", "19")
 6 print(b)
 7 a = "姓名 {name} 年龄 {age}"
 8 b1=a.format(name="小亮亮",age=19)
 9 print(b1)
10 a="我是:{name};年龄:{age}"
11 c=a.format_map({"name":"小亮亮","age":19})
12 print(c)
13 #字典形式键和值
14 #替换字符串里的占位符 输出 姓名 小亮亮 年龄 19

　　　isalnum(self)　

　　　""" （判断字符串是否是纯字母和数字,汉子） 是纯字母或数字汉子返回真，否则返回假"""

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = "小亮亮123aaa"
b = a.isalnum()
print(b)
#输出True  表示是否是数字、汉子

　　isalpha(self)　　

　　""" （是否是纯字母）是字母返回真，否则返回假 """　

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "hsdfujhrt"
4 b=a.isalpha()
5 print(b)
6 #输出 True 表示是纯字母

　　isdigit(self)

　　 """ （是否是纯数字）是纯数字返回真，否则返回假 （三中类型数字的判断）""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 num = ‘123②‘
4 v1 = num.isdecimal() # ‘123‘
5 v2 = num.isdigit()   # ‘123‘，‘②‘
6 v3 = num.isnumeric() # ‘123‘，‘二‘，‘②‘
7 print(v1,v2,v3)
8 #判断是否是数字

　　islower(self)

　　""" （字符串里的字母是否是纯小写）是返回真，否则返回假 """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "小亮亮add12434346"
4 b = a.islower()
5 print(b)
6 #输出 True 表示是纯小写

　　isspace(self)

　　"""(判断字符串是否是纯空格)是返回真，否则返回假"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "  "
4 b = a.isspace()
5 print(b)
6 #输出 True 表示是纯空格

　　istitle(self)　

　　"""(判断英文首字母是否大写)是返回真，否则返回假"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "Nihao"
4 b = a.istitle()
5 print(b)
6 #输出 True 表示首字母是大写

　　isupper(self)

　　"""(判断是否全部字母是大写)是返回真，否则返回假"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "NGGGEAWG"
4 b = a.isupper()
5 print(b)
6 #输出 True 表示字母全部是大写

　　join(self, iterable)有参

　　""" （连接一个列表成一串字符串）"链接符".join(字符串变量)"""

　　注意：如果链接符 " " 为空，链接起来就是一串没有链接符的字符串

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = ["小亮亮" , "TT" , "YY"]
4 b = "互相伤害".join(a)
5 print(b)
6 #输出 小亮亮互相伤害TT互相伤害YY  将列表链接成一串字符串

　　ljust，rjust(self, width, fillchar=None)

　　""" （内容左对齐，右侧填充和内容右对齐，左侧填充）宽度，填充符 """

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 a = "小亮亮"
 4 b = a.ljust(20,"#")
 5 print(b)
 6 #输出 小亮亮###########
 7 #!/usr/bin/env python
 8 # -*- coding:utf-8 -*-
 9 a = "小亮亮"
10 b = a.rjust(20,"#")
11 print(b)
12 #输出 小亮亮###########

　　lower(self)

　　""" （字符串变小写 ）"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "FDHDFrherheh"
4 b = a.lower()
5 print(b)
6 #输出字符串变小写 fdhdfrherheh

　　lstrip(self, chars=None)

　　 """ （移除左侧空白 ）"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "  小亮亮  "
4 b = a.lstrip()
5 print(b)
6 #输出 小亮亮  去除左边空格

　　rstrip(self, chars=None)

　　 """ （移除右侧空白 ）"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "  小亮亮  "
4 b = a.rstrip()
5 print(b)
6 #输出 林贵秀去除右边空格

　　strip(self, chars=None)

　　 """ （移除两边空白 ）"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "  小亮亮  "
4 b = a.strip()
5 print(b)
6 #输出 小亮亮 去除两边空格

　　partition(self, sep)有参

　　 """ （分割，前，中，后三部分）分割位置字符 """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "abcdefjhi"
4 b = a.partition("de")
5 print(b)
6 #输出 (‘abc‘, ‘de‘, ‘fjhi‘) 从位置字符那里分割，返回元组

　　replace(self, old, new, count=None)

　　"""（ 替换）字符串里被替换的字符，替换成什么字符，可选：位置从左向右找几个 """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "小亮亮30岁了"
4 b = a.replace("30", "19")
5 print(b)
6 #输出 小亮亮19岁了 将字符串里的字符替换成指定字符

　　split(self, sep=None, maxsplit=None)

　　 """ （分割字符串），要分割的标示字符，标示字符分割有效位置：也就是从左边开始最多分割几次 """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "fawweffefwefelfqf"
4 b = a.split("e",4)
5 print(b)
6 #输出 [‘faww‘, ‘ff‘, ‘fw‘, ‘f‘, ‘lfqf‘]返回分割后的列表

　　splitlines(self, keepends=False)

　　""" （根据换行分割） """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "fawweffe\nfwefelfqf"
4 b = a.splitlines()
5 print(b)
6 #输出 [‘fawweffe‘, ‘fwefelfqf‘] 返回分割后的列表

　　startswith(self, prefix, start=None, end=None)

　　""" （判断是否以某一个字符或者字符串起始）要判断的字符或字符串：返回真或者假 """

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "中国的城市有北京"
4 b = a.startswith("中国")
5 print(b)
6 #输出 True 返回真

　　swapcase(self)

　　""" （大写变小写，小写变大写 ）"""

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "abcdABCD"
4 b = a.swapcase()
5 print(b)
6 #输出 ABCDabcd 返回大写变小写，小写变大写

　　索引　

索引：把一串字符串分成每个字符为一个新字符串

索引  ：注意2.7版本索引中文字符串会乱码，3.0版本以上没问题 (2.7是以字节编码的，3.0是以字符编码的)

说明：2.7版本中文是以字节编码的，如utf-8 一个中文是3个字节，所以当索引字符下标是一个汉字是有3个下标的，索引一个下标不是一个完整的汉字，就会出现乱码

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "你好"
4 print(a[0])#索引一个下标不是一个完整的汉字，就会出现乱码

2.7版本中，用切片的方法打印一个汉字

说明：切片可以指定字符下标范围，如utf-8 一个中文是3个字节，如果0到3的范围，刚好是一个字

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 a = "你好"
4 print(a[0:3])#用切片的方式0到3，就能打印出（你）字，因为utf-8字符编码一个汉字3个字节

　　判断索引数用 len() 函数  一般配合循环使用

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #索引：把一串字符串分成每个字符为一个新字符串
 4 #以字符下标位置分开
 5 a = "adce"
 6 print(a[0])
 7 print(a[1])
 8 print(a[2])
 9 print(a[3])
10 #如上打印出：a、d、c、e 四个独立的新字符串
11
12 #判断一个字符串有多少个下标字符如下
13 a = "adce"
14 b = len(a)
15 print(b)
16 #输出 4 也就是说这个字符串有4个下标字符

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #索引：结合循环应用
4 # #for循环
5 #b为循环自定义变量
6 a = "zjl”
7 for b in a:
8     print(b)
9 #循环出索引

　　切片　　

　　切片：把一串字符串分成每几个字符或者多个字符，为一个新字符串
　　以字一个字符的下标开始，和一个字符的下标结束，切成一串新的字符串　

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #切片：把一串字符串分成每几个字符或者多个字符，为一个新字符串
4 #以字一个字符的下标开始，和一个字符的下标结束，切成一串新的字符串
5 a = "adcefhwieufgweufhggh"
6 print(a[0:4])
7 print(a[4:10])
8 print(a[10:20])
9 #如上打印出：adce、fhwieu、fgweufhggh 切成四个独立的新字符串

将字符串，转换成16进制，二进制   

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #bytes类,将字符串转换成16进制表示
 4 a = "小亮亮"
 5 print(a)#字符串表示
 6 #输出 小亮亮
 7
 8 #用bytes类，将字符串转换成16进制
 9 print(bytes(a,encoding=‘utf-8‘))#将字符串转换成16进制表示
10 #输出  b‘\xe5\xb0\x8f\xe4\xba\xae\xe4\xba\xae‘16进制表示的二进制
11
12 #用for将16进制循环出10进制
13 b = bytes(a,encoding=‘utf-8‘)#将16进制转换成10进制
14 for i in b:#for循环16进制的时候默认会以10进制方式循环出数据
15     print(i)
16 #输出
    #229
    #176
    #143
    #228
    #186
    #174
    #228
    #186
    #174

%s字符串格式化拼接，将几个字符串拼接在一起
%s为占位符，就是占位的作用，主意：占位符与占位符之间还可以加一个分隔符
%()引用数据到占位符
如果有几个字符串需要拼接
拼接格式:
"占位符要引用几个字符串就写几个占位符" %(要引用的字符串变量)

注意：

%s能接受任何类型

%d只能接受整数类型

%f只能接受浮点数类型

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""
%s字符串格式化拼接，将几个字符串拼接在一起
%s为占位符，就是占位的作用，主意：占位符与占位符之间还可以加一个分隔符
%()引用数据到占位符
如果有几个字符串需要拼接
拼接格式:
"占位符要引用几个字符串就写几个占位符" %(要引用的字符串变量)
"""
a = "你好"
b = "我好"
c = "大家好"
d = "%s%s%s" %(a, b, c)
print(d)
#输出
#你好我好大家好