#1、将字符串转换为数字
a = "123"
v = int(a)
print(v)
print(type(v))#2、当前数字的二进制，至少用几位表示'''
1位等于8个字节.
占2个字节的：带有附加符号的拉丁文、希腊文、西里尔字母、亚美尼亚语、希伯来文、阿拉伯文、叙利亚文及它拿字母则需要二个字节编码占3个字节的：基本等同于GBK，含21000多个汉字占4个字节的：中日韩超大字符集里面的汉字，有5万多个一个utf8数字占1个字节一个utf8英文字母占1个字节少数是汉字每个占用3个字节，多数占用4个字节。
'''
b = 5
v = b.bit_length()
print(v)

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# 1、capitalize(self):
# 作用：首字母大写
'''
name = "a_catinsky"
v = name.capitalize()
print(v)
'''# 2、casefold(self):
# 作用：将所有大写字母变为小写
'''
a = "catInSky"
v = a.casefold()
print(v)
'''# 3、center(self, width, fillchar=None):
# 作用：设置字符占用的总长度
# width:设置总宽度，fillchar:设置填充字符，只能为一个字符。
# 例子：设置变量username的宽度为20字符，并居中显示，不足位置使用*号代替。
'''
username = "cat"
v = username.center(20,'*')
print(v)
'''# 4、count(self, sub, start=None, end=None):
# 作用：统计子序列数量
# start=None, end=None，设置开始的和结束的字符位置
# 例子：统计字符串"c"，在变量username中，从6--10出现的次数。
'''
username = "catinsky_catinsky"
v = username.count("c",6,10)
print(v)
'''# 5、encode与decode(self, encoding='utf-8', errors='strict'):
# 描述：以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
'''
username = "那只猫飞走了"
v1_gbk = username.encode("gbk")
print("GBK编码：",v1_gbk)
v2_utf8 = username.encode("utf-8")
print("UTF-8编码：",v2_utf8)
#反编译，将utf-8编码转换为utf-8
v3 = v1_gbk.decode("gbk")
print("反编译GBK：",v3)
v4 = v2_utf8.decode("utf-8")
print("反编译UTF-8：",v4)
'''
# 6、decode
# 以指定的编码格式解码字符串，示例如上。# 7、endswith(self, suffix, start=None, end=None)：
# 判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。
# 可选参数"start"与"end"为检索字符串的开始与结束位置。
'''
username = "catinsky"
v = username.endswith("in",2,5)
print(v)
a = username.startswith("cat",0,10)
print(a)
'''
# 8、startswith
# 判断字符串是否以指定字符开始，结果返回bool值。示例如上。# 9、expandtabs(self, tabsize=8):
# 描述：把字符串的Tab符号(/t)，转换为空格。默认空格数量是8。
# 参数：tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。
# 参数：tabsize -- 跟center函数类似。设置字符占用的总长度，不足的用空格补上，且左对齐。而center是居中。
# 例1：
'''
text = "username\tpassword\temail\ncatinsky\t******\tcatinsky@qq.com\ncat\t******\tcat@qq.com"
v = text.expandtabs(15)
print(v)
'''
# 例2：
'''
test = "My name is\tcat\tinsky,What is your name?"
v = test.expandtabs()
print(v)
'''# 10、find(self, sub, start=None, end=None):
# 描述：检查字符串中，是否包含指定字符。如果包含则返回开始的索引值，否则返回数字-1.
'''
username = "catinskyc"
user = "in"
v = username.find(user)
print(v)                        # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：3
print(username.find("c"))       # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：0
print(username.find("c",1))     # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：8
print(username.find("p",0))     # 从下标0开始，查找在字符串里第一个出现的子串，返回结果：-1
'''# 11、format(self, *args, **kwargs):
# 描述：格式化函数
'''
print("我的名字：{name},我的邮箱：{url}".format(name = "李白",url = "libai@qq.com"))
# 通过字典设置参数
site = {"name": "我的名字", "url": "www.abc.com"}
print("网站名：{name}, 地址 {url}".format(**site))# 通过列表索引设置参数
my_list = ['我的名字', 'www.abc.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
'''# 12、index(self, sub, start=None, end=None):
# index() 方法检测字符串中是否包含子字符串 str ，如果指定 start（开始） 和 end（结束） 范围，
# 则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
# 不建议使用此函数，不如使用find函数。因为如果不包含时，报错，而find是返回数值-1。# 13、isalnum(self):
# 描述：检测字符串是否由字母和数字组成。
'''
name = "catinsky01"     #字符中没有空格
v = name.isalnum()
print(v)    #结果为：Truename1 = "catinsky 01"     #字符中有空格
v = name1.isalnum()
print(v)    #结果为False
'''# 14、isalpha(self):
# 描述：检测字符串是否全部由字母组成，全部为字母返回True，否则返回false。
'''
name = "catinsky "
v = name.isalpha()
print(v)    #有空格则为False
'''# 15、isdecimal(self):
# 判断字符串是否只有数字组成，不能判断 ①② 这种数字。返回值为True或False:
'''
text = "123①"
v = text.isdecimal()
print(v)    #返回结果为False;
'''# 16、isdigit(self):
# 判断字符串是否只有数字组成，能判断 ①② 这种数字。返回值为True或False:
'''
text = "123①"
v = text.isdigit()
print(v)    #返回结果为True;
'''
# 17、isnumeric(self):
# 检测字符串中只包含数字字符，则返回 True，否则返回 False
# 如果是utf-8汉字，则为True，比如一、二、三等
'''
text = "abc123"
v1 = text.isdecimal()
v2 = text.isdigit()
v3 = text.isnumeric()
print(v1)
print(v2)
print(v3)text = "二"
v1 = text.isdecimal()
v2 = text.isdigit()
v3 = text.isnumeric()
print(v1)
print(v2)
print(v3)
'''
# isdecimal、isdigit、isnumeric的区别
'''
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
False: 汉字数字
Error: 无isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字
Error: byte数字（单字节）isnumeric()
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
False: 无
Error: byte数字（单字节）
'''# 18、isidentifier(self):
# 判断字符串是否以字母、数字、下划线开头。返回值为True或False。
'''
text = "_123"
v = text.isidentifier()
print(v)    #返回值True
text = "abc"
v = text.isidentifier()
print(v)    #返回值True
text = "123"
v = text.isidentifier()
print(v)    #返回值False
'''# 19、islower(self):
# 判断字符串字母是否都是小写或数字，则返回 True，否则返回 False。
'''
test = "Acb"
v1 = test.islower()
print(v1)   #结果为False
test = "abc123"
v2 = test.islower()
print(v2)   #结果为True
'''# 20、isprintable(self):
# 判断是否存在不可见字符，例如换行符\n,\t等。
'''
test = "catin\tsky"
v = test.isprintable()
print(v)    #结果为False
'''# 21、isspace(self):
# 判断是否全部是空格
'''
test = "   "
v1 = test.isspace()
print(v1)   #结果为True
test = "cat  in  sky"
v2 = test.isspace()
print(v2)   #结果为False
'''# 22、title(self):
# 23、istitle(self):
# title，将字符串转换为标题，每个单词首字是大写的就是标题。
# istitle，判断字符串是否为标题，返回值为True或False。
'''
test = "My name is catinsky"
v1 = test.istitle()
print(v1)   #结果为False
v2 = test.title()
print(v2)   #结果为"My Name Is Catinsky"
v3 = v2.istitle()
print(v3)   #结果为True
'''# 24、isupper(self):
# 判断字符串是否全部是大写
# upper，将字符串转换为全部是大写
'''
test = "MY NAME IS CATINSKY"
v1 = test.isupper()
print(v1)   #结果为True
test = "My Name is catinsky"
v2 = test.isupper()
print(v2)   #结果为False
'''# 25、join(self, iterable):
# 将序列中的元素以指定的字符连接生成一个新的字符串。
'''
text = "春风又绿江南岸"
t = "_"
v = t.join(text)
print(v)
'''# 26、ljust(self, width, fillchar=None):
# 27、rjust(self, width, fillchar=None):
# 28、zfill(self, width):
# 原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
# 原字符串右对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
# 返回长度为 width 的字符串，原字符串右对齐，前面填充0
'''
test = "catsky"
v1 = test.ljust(20,"*")
print(v1)   #输出结果为：catsky**************
v2 = test.rjust(20,"#")
print(v2)   #输出结果为：##############catsky
'''# 29、lower(self):
# 将字符串全部转换为小写
# islower判断字符串是否全部为小写
'''
test = "CatInsky"
v = test.lower()
print(v)
'''# 30、upper:
# 将字符串全部转换为大写
# isupper判断字符串是否全部为大写
'''
name = "catinsky"
v = name.upper()
print(v)
'''# 31、lstrip(self, chars=None):
# 32、rstrip(self, chars=None):
# 33、strip(self, chars=None):
# 用于去除字符串左边的空格（包含\n和\t）或指定字符。
# 用于去除字符串右边的空格（包含\n和\t）或指定字符。
# 用于去除字符串左边和右边的空格（包含\n和\t）或指定字符。只能去除两边，不能去除中间字符。
# 笔记：1、strip() 处理的时候，如果不带参数，默认是清除两边的空白符，例如：/n, /r, /t, ' ')。
# 2、strip() 带有参数的时候，这个参数可以理解一个要删除的字符的列表，是否会删除的前提是从字符串
# 最开头和最结尾是不是包含要删除的字符，如果有就会继续处理，没有的话是不会删除中间的字符的。
'''
name = "***my* *name* ***is*** ***catinsky***"
v1 = name.strip("*")
print(v1)
#输出结果为： my* *name* ***is*** ***catinsky，去除左右两边的*字符，不能去除中间的。
name = " cat in sky "
v2 = name.strip()
print(v2)   #返回结果为：cat in sky，默认去除左右两边的空格，但不能去除中间的。
name = "catinsky\t   "
v3 = name.strip()
print(v3)   #输出结果为catinsky，去除了\t和右边的空白。
name = "catinsky"
v4 = name.strip("in")
print(v4)   #输出结果为catinsky，不能去除中间的in字符。
'''# 34、maketrans(self, *args, **kwargs):
# 35、translate(self, table):
# maketrans,创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
# 第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# translate,根据 maketrans 给出的表，替换为新的字符串。
'''
a = "ctns"
trans_name = "1235"
name = "catinsky"
v1 = name.maketrans(a,trans_name)   #制作翻译表
print(name.translate(v1))
'''# 36、partition(self, sep):
# 37、rpartition(self, sep):
# 将字符串以指定字符分隔，只能分成3部分，且去除分隔字符。# 38、split(self, sep=None, maxsplit=-1):
# 39、rsplit(self, sep=None, maxsplit=-1):
# 通过指定分隔符对字符串进行切片，可分多个部分，且去除分隔字符。
# split()方法语法：
# str.split(str="", num=string.count(str))
# str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
# num -- 分割次数。# 40、splitlines(self, keepends=None):
# 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，
# 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
# partition例子：
'''
name = "catinskycatinsky"
v1 = name.partition("s")
print(v1)   #返回结果为：('catin', 's', 'kycatinsky')
'''
# split例子1：
'''
name = "catinskycatinskycatinsky"
v2 = name.split("s")
print(v2)   # 返回结果为：['catin', 'kycatin', 'kycatin', 'ky']
'''
# split例子2：
'''
str = "this is string example....wow!!!"
print (str.split( ))      # 输出结果：['this', 'is', 'string', 'example....wow!!!']
print (str.split('i',1))  # 输出结果：['th', 's is string example....wow!!!']
print (str.split('w'))    # 输出结果：['this is string example....', 'o', '!!!']
'''# 41、replace(self, old, new, count=None):
# 把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
# 语法：str.replace(old, new[, max])
# 参数：
# old -- 将被替换的子字符串。
# new -- 新字符串，用于替换old子字符串。
# max -- 可选字符串, 替换不超过 max 次
'''
str = "www.w3cschool.cc"
print ("菜鸟教程旧地址：", str)
print ("菜鸟教程新地址：", str.replace("w3cschool.cc", "runoob.com"))str = "this is string example....wow!!!"
print (str.replace("is", "was", 3))
以上实例输出结果如下：菜鸟教程旧地址： www.w3cschool.cc
菜鸟教程新地址： www.runoob.com
thwas was string example....wow!!!
'''# 42、swapcase(self):
# 将字符串中大写转换为小写，小写转换为大写
'''
name = "Cat in Sky !"
v = name.swapcase()
print(v)    #返回结果为：cAT IN sKY !
'''# #################字符串的灰魔法##################
# 43、获取字符串中的某一个字符
# 获取指定字符
'''
name = "catinsky"
v = name[1]
print(v)    # 返回结果为:a
'''
# 切片
'''
name = "catinsky"
v1 = name[0:4] # 获取大于等0，小于4之间的字符
print(v1)   # 返回结果为：cati
'''
# 例子2：
'''
name = "catinsky"
v2 = name[0:-2] # 获取第1个至倒数第2个之间的字符，包含第1个，但不包含倒数第2个。
print(v2)   # 返回结果为：catins
'''# 44、len获取字符串中有几个字符组成
'''
name = "春风又绿江南岸"
v = len(name)
print(v)    # 返回结果为7，在python2中则是其他数字。
'''# 45、for循环
'''
name = "春风又绿江南岸"
for i in name:print(i)
'''# 46、用户输入验证码
"""
def check_code():import randomcheckcode = ''for i in range(4):current = random.randrange(0,4)if current != i:temp = chr(random.randint(65,90))else:temp = random.randint(0,9)checkcode += str(temp)return checkcodewhile True:code = check_code()print(code)user_code = input(">>>请输入验证码：")v = user_code.upper()if code == v:print("验证通过")breakelse:print("验证码错误")
"""# 屏蔽关键字
'''
user_input = input("请输入内容：")
maket = ("苍井空,东京热")
trans = ("***,***")
v1 = user_input.maketrans(maket,trans)
print(user_input.translate(v1))
'''

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# ###############列表的8个特征###############
# 1、列表(list)的格式、特点
"""
li = [11,"字符串",["列表",23],True]
列表可以包含数字、字符串、列表、布尔值，例如：
"""
# 2、列表可以索引取值
"""
li = [11,"李白",["刘备",["曹操",23]],True]
v = li[2][1][0]
print(v)    # 返回结果为：曹操
"""
# 3、列表可以切片取值
"""
li = [11,"李白",["刘备",["曹操",23]],True]
v = li[1:-1]    # 取第一个至倒数第一个之间的值
print(v)
"""
# 4、列表可以for和while循环
"""
li = [11,"李白",["刘备",["曹操",23]],True]
while True:if "李白在" in li:print("存在")breakelse:print("不存在")break
"""
# 5、列表可以被修改（索引和切片都可以修改）
# a、索引修改
"""
li = [11,"李白",["刘备",["曹操",23]],True]
li[1] = "孙权"
print(li)
"""
# b、切片修改
"""
li2 = [11,"李白",["刘备",["曹操",23]],True]
li2[1:3] = ["关羽", "张飞", "刘备"]
print(li2)
"""
# 6、列表可以被删除
# a、索引删除
"""
li = [11, "李白", ["刘备", ["曹操", 23]], True]
del li[2][1][1]  # 删除数字23
print(li)
"""
# b、切片删除
"""
li = [11, "李白", ["刘备", ["曹操", 23]], True]
del li[1:3] # 删除索引0-3之间的元素，不会删除索引位置为3的元素
print(li)   # 返回结果为：[11, True]
"""
# 7、in 操作，结果为布尔值
"""
li = [11, "李白", ["刘备", ["曹操", 23]], True]
v1 = "刘备" in li
print(v1)   # 返回结果为：False
v2 = "李白" in li
print(v2)   # 返回结果为：True
"""
# 8、数据类型转换
# a、字符串转换为列表
"""
a = "coincidance"
a1 = "新三国"
v = list(a)
print(v)    # 返回值为：['c', 'o', 'i', 'n', 'c', 'i', 'd', 'a', 'n', 'c', 'e']
# 将字符串的每个字符for循环后，当为列表的元素。
"""
# b、将列表转换为字符串
# 方法1：
"""
a = [123,"abc",[5,"刘备"]]
v = str(a)
print(a)    # 返回结果为：[123, 'abc', [5, '刘备']]
# 将整个列表当作字符串处理。
"""
# 方法2：
"""
b = [123,"abc",[5,"刘备"]]
s = ""
for i in b:s = s + str(i)
print(s)    # 返回结果为：123abc[5, '刘备']
# 定义变量s接收for循环的值，for循环的i值转换为字符串，然后字符可以相加拼接。
"""
# 9、字符串一旦被创建，便不能修改
"""
a = "abc"
a = a.replace("a","99")
print(a)
"""
# ###############列表list的函数###############
# 1、len(list)
# 列表的元素个数
"""
list1 = ['Google', 'Runoob', 'Taobao']
print(len(list1))
list2 = list(range(5))  # 创建一个 0-4 的列表
print(len(list2))
"""
# 2、max(list)
# 列表元素最大值
"""
list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]
print ("list1 最大元素值 : ", max(list1))
print ("list2 最大元素值 : ", max(list2))
"""
# ###############列表list的功能###############
# 1、append(self, p_object):
# 在列表末尾添加新的对象object
"""
li = [123,"abc",[5,"刘备"]]
v = li.append([23,"关羽"])
print(v)
print(li)
"""
# 2、clear(self):
# 清空列表
"""
li = [123,"abc",[5,"刘备"]]
li.clear()
print(li)
"""
# 3、copy(self):
# 使用=直接赋值，是引用赋值，更改一个，另一个同样会变。复制一个副本，原值和新复制的变量互不影响。
"""
li = [0,1,2,3,4,5]
a = li
b = li.copy()
del a[1]
b.append(9)
print(li)   # 返回值：[0, 2, 3, 4, 5]
print(a)    # 返回值：[0, 2, 3, 4, 5]
print(b)    # 返回值：[0, 1, 2, 3, 4, 5, 9]
"""
# 4、count(self, value):
# 统计某个元素在列表中出现的次数
"""
li = [0,1,2,3,4,5,2,2]
v = li.count(2)
print(v)
"""
# 5、extend(self, iterable):
# 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
"""
list1 = ["关羽","张飞","刘备"]
list2 = list(range(5))
print(list2)    # 返回结果为：[0, 1, 2, 3, 4]
list1.extend(list2)
print(list1)    # 返回结果为：['关羽', '张飞', '刘备', 0, 1, 2, 3, 4]
"""
# 6、index(self, value, start=None, stop=None):
# 从列表中找出某个值第一个匹配项的索引位置
"""
li = [11, 22, 33, 22, 44]
v = li.index(22)
print(v)
"""
# 7、insert(self, index, p_object):
# 将对象插入列表
"""
list1 = ["关羽","张飞","刘备"]
list1.insert(1,"赵云")    # 在索引为1的位置插入字符串“赵云”。
print(list1)    # 返回结果为：['关羽', '赵云', '张飞', '刘备']
"""
# 8、pop(self, index=None):
# 删除某个值(1.指定索引；2. 默认最后一个)，并获取删除的值。
"""
list1 = ["关羽", "张飞", "刘备"]
v1 = list1.pop()
print("默认删除最后一个元素：", v1.center(6))
print ("删除后的列表：", str(list1).center(30))list2 = ["关羽", "张飞", "刘备"]
list2.pop(1)    # 指定删除的索引位置
print(list2)    # 返回值为：['关羽', '刘备']
"""
# 9、remove(self, value):
# 移除列表中某个值的第一个匹配项
"""
list1 = ["关羽", "张飞", "刘备"]
list1.remove("关羽")
print(list1)    # 返回值为：['张飞', '刘备']
"""
# 10、reverse(self):
# 将列表中的元素进行反转
"""
list1 = ["关羽", "张飞", "刘备"]
list1.reverse()
print(list1)    #返回值为：['刘备', '张飞', '关羽']
"""
# 11、sort(self, key=None, reverse=False):
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
"""
li = [11,44, 22, 33, 22]
li.sort()
print(li)
"""

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# ########元组Tuple的特点########
# 1、元组里的一级元素，不可被修改，删除或者增加。
# tu = (11,"刘备",[22,"列表"],(33,"元组"),True)
# 2、元组的索引
"""
tu = (11,"刘备",[22,"列表"],(33,"元组"),True,)
v = tu[1]
print(v)    # 返回结果为：刘备
"""
# 3、元组的切片
"""
tu = (11,"刘备",[22,"列表"],(33,"元组"),True,)
v = tu[0:2]
print(v)    #返回结果为：(11, '刘备')
"""
# 4、元组的转换
"""
tu1 = "字符串"
tu2 = [11, "列表"]
tu3 = (22, "元组",)
v1 = tuple(tu1)  # 将字符串转换为元组
print(v1)  # 返回结果为：('字', '符', '串')
v2 = tuple(tu2)  # 将列表转换为元组
print(v2)  # 返回结果为：(11, '列表')
v3 = list(tu3)  # 将元组转换为列表
print(v3)   # 返回结果为：[22, '元组']
"""
# 5、元组的一级元素不可被修改、删除、增加
"""
tu = (11, "刘备", [22, "列表"], (33, "元组"), True,)
tu[2][1] = "关羽"  # 元组二级元素的修改
print(tu)  # 返回结果为：(11, '刘备', [22, '关羽'], (33, '元组'), True)
tu[2].append("赵云")
print(tu)   # 返回结果为：(11, '刘备', [22, '关羽', '赵云'], (33, '元组'), True)
tu[2].insert(0, "孙权")
print(tu)   # 返回结果为：(11, '刘备', ['孙权', 22, '关羽', '赵云'], (33, '元组'), True)
"""