1. 整型

  整型即整数，用 int 表示，在 Python3 中整型没有长度限制。

1.1 内置函数

  1. int（num, base=None）

  int( ) 函数用于将字符串转换为整型，默认转换为十进制。

>>> int('123')
123
>>> int('123', base=16)
291

  2. bit_length( num)

  当前数字的二进制，至少用多少位表示。

>>> a = 5
>>> a.bit_length()
3

2. 浮点型

  浮点型即小数，用 float 表示，也可以用科学计算法表示。

>>> a = 0.005
>>> a           # 科学计数法
5e-3

  类型转换：

>>> float(2)
2.0
>>> float('2')
2.0

3. 布尔型

  布尔型是一种特殊的整型，用 True 和 False 或 0 和 1 表示，Python 中是 False 的有：

• None、""、0、[ ]、（）、{ }

  类型转换：

>>> bool(None)
False

4. 字符串

  字符串是 Python 里的文本，用 str 表示，创建一个字符串使用单引号【' '】或双引号【" "】，引起即可。

字符串一旦创建，不可修改，同时它也是可迭代对象。

  如果字符串中的内容既有单引号，又有双引号，有两种办法解决：

• 使用转义符号【\】对字符串中的引号转义

>>> 'Let\'s go'
"Let's go"

• 使用不同的引号表示

>>> "Let's go"
"Let's go"

4.1 长字符串

  当字符串内容行数比较多时，我们可以使用 三重引号引起内容。

>>> print("""
... 从明天起，做一个幸福的人
... 喂马，劈柴，周游世界
... """)

从明天起，做一个幸福的人
喂马，劈柴，周游世界

4.2 内置方法

  PART 1：

# capitalize（）：将字符串内容首字母转换为大写
>>> s = 'i am rose'
>>> s.capitalize()
'I am rose'

# casefold（）：将字符串的所有字符转换为小写，与 lower（）一样，但是可以转换特殊字符

# lower（）：将字符串里的所有字符都转换为小写
>>> s = 'i love You'
>>> s.lower()
'i love you'

# upper（）：将字符串里的所有字符都转换为大写
>>> s.upper()
'I LOVE YOU'

# count（sub，start，end）：统计字符串中某个字符出现的次数，可指定范围
>>> s = 'i am Rose, age 18'
>>> s.count('a')
2
>>> s.count('a', 3, 5)
0

# startswith（suffix，start，end）、endswith（suffix，start，end）
# 查找这个字符串，判断是以什么字符开头或结尾，返回布尔值，可指定范围
>>> s = 'i am Rose, age 18'
>>> s.startswith('I')
True
>>> s.endswith('I')
False

# find（sub，start，end）：查找某个字符，返回其下标，若有多个只返回第一个的下标，若不存在则返回 -1
>>> s = 'I am rose'         # 空格也占位
>>> s.find('a')
2

# index（sub，start，end）：与 find（）一样，但是不存在则抛出 ValueError

# format（*args，**kwargs）：格式化字符串，将字符串中的占位符替换为指定值，不限参数（可以是位置、关键字参数）
>>>'I am {0}, age {1}'.format('rose', 18)   # 位置参数
>>>'I am {name}, age {age}'.format(name='rose', age=18)     # 关键字参数

>>> d = {'name': 'rose', 'age': 18}     # 传入字典（加 **）
>>>'I am {name}, age {age}'.format(**d)

>>> l = ['rose', 18]        # 传入列表（加 *）
>>> 'I am {:s}, age {:d}'.format(*l)
'I am rose, age 18'

# format_map（）：格式化字符串，接收字典
>>> 'I am {name}, age {age}'.format_map({'name': 'rose', 'age': 18})
'I am rose, age 18'

# isalnum（）：判断当前字符串是否只包含字母或数字，返回布尔值
>>> s1 = 'sda12'
>>> s.isalnum()
True
>>> s2 = '12'
>>> s2.isalnum()
True
>>> s3 = 's_'
>>> s3.isalnum()
False

# isalpha（）：判断当前字符串所有字符是否都是字母，包括汉字，返回布尔值
>>> s1 = 'sda12'
>>> s1.isalpha()
False
>>> s2 = '汉字'
>>> s2.isalpha()
True

# isdecimal（）：判断当前字符串所有字符是否都是数字，返回布尔值
>>> s = '123'
>>> s.isdecimal()
True
>>> s1 = '123s'
>>> s1.isdecimal()
False

# isdigit（）：判断当前字符串所有字符是否都是数字，可识别 ②，返回布尔值
>>> s2 = '②'
>>> s2.isdigit()
True
>>> s3 = '二'
>>> s3.isdigit()
False

# isnumeric（）：判断当前字符串所有字符是否都是数字，可识别 ②，和二，返回布尔值
>>> s3.isnumeric()
True

# isprintable（）：判断字符串是否存在不可显示的字符，如 \t、\n，空格等返回布尔值
>>> s6 = ''
>>> s6.isprintable()
True
>>> s6 = ' '
>>> s6.isprintable()
True

# isspace（）：判断字符串是否都是空格，返回布尔值
>>> s5.isspace()
True
>>> s6 = ''
>>> s6.isspace()
False

# istitle（）：判断字符串中每个单词首字母是否都是大写，即是否是标题
>>> s = 'i love you'
>>> s.istitle()
False

# title（）：将字符串标题化
>>> s.title()
'I Love You'

  PART 2：

# join（iterable）：以字符串为分隔符，插入到序列的每个字符间，传入的列表、元组等，其中的元素必须是字符串不能是数字
>>> '-'.join('内置方法')        # 以 - 分隔符
'内-置-方-法'
>>> ' '.join('内置方法')
'内 置 方 法'
>>> '-'.join(['abd', '123'])
'abd-123'

# ljust（width，fillchar=None）：将字符串居左，右边以字符填充，默认以空格填充，可以指定宽度
# rjust（width，fillchar=None）：将字符串居右，左边以字符填充，默认以空格填充，可以指定宽度
# center（width，fillchar=None）：将字符串居中，两边以字符填充，默认以空格填充，可以指定宽度
>>> s = 'love'
>>> s.ljust(10, '*')
'love******'
>>> s.rjust(10, '*')
'******love'
>>> s.center(10, '*')
'***love***'

# zfill（width）：返回长度为 width 的字符串，原字符串右对齐，前面以 0 填充
>>> s = 'abc'
>>> s.zfill(10)
'0000000abc'

# islower（）、isupper（）：判断字符串所有字符是否都是小写或大写，返回布尔值
>>> s = 'i love you'
>>> s.islower()
True
>>> s.isupper()
False

# lstrip（chars=None）：去掉字符串左边所有空格，包括 \t、\n
# rstrip（chras=None）：去掉字符串右边所有空格，包括 \t、\n
# strip（chras=None）：去掉字符串两边所有空格，包括 \t、\n
>>> s = '   123  '
>>> s.lstrip()
'123  '
>>> s.rstrip()
'   123'
>>> s.strip()
'123'

# partition（sep）：separator 分隔符，从左边开始分割字符串，只能分成三份，多个时只返回第一个
>>> s = 'testsadsabc'
>>> s.partition('s')
('te', 's', 'tsadsabc')

# rpartition（sep）：从右边开始分割字符串，只能分成三份，多个时只返回第一个
>>> s.rpartition('s')
('testsad', 's', 'abc')

# split（sep=None，maxsplit=-1）：不带参数，默认以空格分割字符串，可指定最大分割次数，返回分割后子串列表
>>> s = 'testlosve'     # 不包含分割字符
>>> s.split('s')
['te', 'tlo', 've']

# rsplit（sep=None，maxsplit=-1）：从右边分割字符串，与 split（）类似
>>> s.rsplit('s')
['te', 'tlo', 've']

# splitlines（[keepends]）：以 \n 分割，返回一个列表，TRUE、False 表示是否保留换行符
>>> s = 'testab\ncd\nh'
>>> s.splitlines()
['testab', 'cd', 'h']
>>> s.splitlines(True)
['testab\n', 'cd\n', 'h']
>>> s.splitlines(False)
['testab', 'cd', 'h']

# swapcase（）：翻转大小写
>>> s = 'abc'
>>> s.swapcase()
'ABC'

# maketrans（）：用于创建字符映射的转换表，两个参数，第一个为要转换的字符，第二个为转换的目标，两者长度一致
# translate（table）：根据 table规则（由 str.maketrans（'a', 'b')制定），转换字符串字符。
>>> s = 'this is string'
>>> s.translate(s.maketrans('aeiou', '12345'))      # aeiou 与 12345 一一对应
'th3s 3s str3ng'

# replace（old，new[，count]）：把字符串中的 old 字符替换成 new 字符，count 为替换次数，可选
>>> s = 'hello'
>>> s.replace('e', 'h')
'hhllo'
>>> s       # 不改变原始字符串
'hello'

# expandtabs（[tabsize=8]）：将字符串中的 \t 转换为空格，可指定长度，默认 tabsize = 8
>>> s = 'username\teamil\tpassword\nlixiang\tlixiang@qq.com\t123456'
>>> s.expandtabs(20)
username            eamil               password
lixiang             lixiang@qq.com      123456

# bit_length（）：返回一个 int 用二进制表示需要多少位，不包含前导数和符号
>>> n = 37
>>> n.bit_length()
6

# bin（number）：返回一个 int 的二进制表示
>>> bin(37)
'0b100101'          # 37 用二进制表示，刚好 6 位

# encode（encoding='utf-8', errors='strict）：以 encoding 方式编码字符串，errors 指定不同的错误处理方案，返回编码后的字符串，是一个 bytes 对象
# bytes.decode（encoding='utf-8', errors='strict）：以指定的编码格式解码 bytes 对象，默认 utf-8
>>> s = '编码解码'
>>> s1 = s.encode('utf-8')
>>> s2 = s.encode('gbk')
>>> s1
b'\xe7\xbc\x96\xe7\xa0\x81\xe8\xa7\xa3\xe7\xa0\x81'
>>> s2
b'\xb1\xe0\xc2\xeb\xbd\xe2\xc2\xeb'

>>> s1.decode('utf-8', 'strict')        # 解码，以什么方式编码就以什么方式解码
'编码解码'
>>> s2.decode('gbk', 'strict')
'编码解码'

4.3 索引

  获取字符串中某个字符，只需传入索引即可，索引从 0 开始，支持负数索引（最后一个为 -1）

>>> s = 'hello'
>>> s[0]
'h'
>>> s[-1]
'o'

  字符串是可迭代对象，因此也支持切片：

>>> s = 'hello'
>>> s[0:2]
'he'
>>> s[-2:-1]
'l'

  同样地 也支持 for 循环遍历其中每一个元素：

>>> for i in s:
...     print(i)
...
h
e
l
l
o

4.4 内置函数

  len（）可以获取字符串长度

>>> len('hi')
2

4.5 字符串拼接

  为了保证内存的连续性，字符串一旦创建，不允许被修改；一旦修改，将会产生新的字符串，使用连接符 + 可以将两个字符串拼接成一个新的字符串。

>>> myteacher = '李'
>>> yourteacher = '老师'
>>> ourteacher = myteacher + yourteacher
>>> ourteacher
'李老师'

  Python 中不同数据类型是不能拼接的，但是可以使用别的方法实现：

>>> print('score' + ':' + str(95))  # 使用 + 连接符需要考虑是否是相同数据类型
score:95
>>> print('score:',95)         # 可以不用考虑数据类型
score: 95

4.6 原始字符串

  所有的字符串都是按照字面的意思来使用，没有转义特殊和不能打印的字符。

  当字符串中有反斜杠 \ 时，往往会被当成转义字符处理，而有些时候我们并不需要将反斜杠保存下来，有两种方法，一是再加一个反斜杠将其保存下来，但是当反斜杠很多时候，就显得很乱：

>>> s = 'c:\\now'
>>> s
'c:\\now'
>>> print(s)
c:\now

  另一个方法就是使用原始字符串 raw，只需要在字符串前面加个 r 即可，它会自动在程序内部添加反斜杠，无需手动添加：

>>> s = r'c:\now'
>>> s               # 自动添加 \
'c:\\now'
>>> print(s)
c:\now

4.7 格式化字符串

  格式化字符串，即将字符串中的占位符替换为指定值。

  1. format（）

  format（）方法接收位置参数和关键字参数，分别使用位置、关键字占位：

  语法：

format（*args，**kwargs）

  位置参数：

>>>'I am {0}, age {1}'.format('rose', 18)   # 位置参数
I am rose, age 18

  关键字参数：

>>>'I am {name}, age {age}'.format(name='rose', age=18)     # 关键字参数
I am rose, age 18

  也可以接收列表和字典作为参数传入，只需在列表前面添加 *，字典前面添加 ** 即可：

>>> d = {'name': 'rose', 'age': 18}     # 传入字典（加 **）
>>>'I am {name}, age {age}'.format(**d)

>>> l = ['rose', 18]        # 传入列表（加 *）
>>> 'I am {:s}, age {:d}'.format(*l)
'I am rose, age 18'

  2. 格式化操作符 %

  Python 提供了一系列的格式化操作符，用于格式化字符串。

<center>Python 常见格式化操作符及含义</center>

符号	含义
%s	格式化字符串
%d	格式化整数
%c	格式化字符及 ASCII 码
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制（大写）
%f	格式化浮点数，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e，用科学计数法格式化浮点数
%g	根据值的大小决定使用 %f 或 %e
%G	z作用同 %g，根据值的大小决定使用 %f 或 %E

  示例：

>>> msg = 'I am %s, age %d' % ('rose', 18)                        
>>> msg                                                           
'I am rose, age 18'                                               

# 保留两位有效小数（在 f 前面添加 .2）
>>> s = 'percent: %.2f' % 97.687                                  
>>> s                                                             
'percent: 97.69'

# 保留百分号（在 f 后面添加两个 %）
>>> s1 = 'percent: %.2f%%' % 97.687                               
>>> s1                                                            
'percent: 97.69%' 

>>> s2 = 'I am %(name)s, age %(age)d' % {'name':'rose', 'age':18} 
>>> s2                                                            
'I am rose, age 18' 

>>> s3 = 'I am %(pp).2f' % {'pp':123.4567}                        
>>> s3                                                            
'I am 123.46'                                                     

5. 练习题

  1. Python 2 和 Python 3 中 range（）区别？

• Python 2：直接全部生成所有数字，xrange 与 Python 3 一样
• Python3：循环一次生成一个，节省内存

  2. 实现一个加法计算器（如 5 + 9）？

value = '5 + 9'
v1, v2 = value.split('+')
print(int(v1) + int(v2))

  3. int 和 2、str 和 ‘xx' 的关系？

  类和对象的关系

  4. 计算用户输入的内容有几个数字，几个字母？

n = input('请输入内容：')     # input（）接收的内容为 字符串
a = 0, b = 0            # 统计数字、字母
for i in n:             # 对内容遍历循环
    if i.isdecimal():   # 判断是否是数字
        a += 1
    else:
        b +=1
print(a, b)

  5. 制作随机验证码，不区分大小写

  流程如下：

• 用户执行程序
• 给用户显示要输入的验证码
• 用户输入验证码
• 判断用户输入的验证码是否和随机生成的相同，相同则打印输入正确，否则重新输入

# 每次生成一个字符，循环四次，生成四个字符，即一个验证码
import random

verify_coe = ''
for i in range(4):
    current = random.randrange(0, 4)    #
    if current != i:
    # chr()可以将数字转换为 ASCII 码表中所对应的字符，65~90 对应 A~Z，98~122 对应 a~z
    # 生成一个 65~90 的随机整数，并将其转换为大写字母
        temp = chr(random.randint(65, 90))
    else:
        temp = random.randint(0, 9)     # 生成一个 0~9 的随机整数
    verify_code += str(temp)
    
while True:
    n = input('请输入验证码：')
    if n.upper == verify_code:
        print('输入正确')
        break
    else:
        print('输入错误，请重新输入')

  使用函数写：

import random

def check_code():
    """
    生成随机验证码
    :return: 验证码
    """
    verify_code = ''
    for i in range(4):
        current = random.randrange(0, 4)    #
        if current != i:
            # chr()可以将数字转换为 ASCII 码表中所对应的字符，65~90 对应 A~Z，98~122 对应 a~z
            # 生成一个 65~90 的随机整数，并将其转换为大写字母
            temp = chr(random.randint(65, 90))
        else:
            temp = random.randint(0, 9)     # 生成一个 0~9 的随机整数
        verify_code += str(temp)
    return verify_code


def verify(code):
    """
    验证用户输入的验证码是否与随机生成的一致
    :param code:
    :return:
    """
    while True:
        n = input('请输入验证码：')
        if n.upper() == code:       # 不区分大小写
            print('输入正确')
            break
        else:
            print('输入错误，请重新输入！')


def main():
    code = check_code()
    print(code)
    verify(code)
main()

  6. 制作表格

  循环提示用户输入：用户名、密码和邮箱（不超过 20 个字符，超过只取前 20 个字符，）若输入 q 或 Q 则退出，将内容以表格形式显示：

s = ''
while True:
    user = input('请输入用户名：')
    if user == 'q' or user == 'Q':
        break
    psd = input('请输入密码：')
    email = input('请输入邮箱：')
    user_one = user[0:20]
    psd_one = psd[0:20]
    email_one = email[0:20]
    
    temp1 = 'username\tpassword\temial\n'
    temp2 = '{0}\t{1}\t{2}\n'
    a = temp2.format(user_one, psd_one, email_one)
    s += a
    print(temp1.expandtabs(20), s.expandtabs(20))

请输入用户名：rose
请输入密码：123456
请输入邮箱：123456@qq.com
username            password            emial
 rose                123456              123456@qq.com