目录

• for 循环
  • 1.循环
  • 2.循环取值
  • 3.range
  • 4.for + break
  • 5.for+continue
  • 6.for + else
• 数字类型内置方法
  • 整型
  • 浮点型
  • 字符串
    • 1.作用
    • 2.作用
    • 3.使用方法
    • 4.有序or无序：
    • 5.可变or不可变：
  • 列表内置方法
    • 1.作用
    • 2.定义方式
    • 3.使用方法
    • 4.有序 or 无序
    • 5.可变 or 不可变

for 循环

1.循环

重复某种规律做一件事。

while可以循环一切事物

2.循环取值

for 变量名（会拿到容器内的每一个值） in 容器类元素

print （变量名）

lt=[1,2,3,4]
for i in lt:
    print(i)
    

dic={'a':1,'b':2,"c"=3}
for i in dic:   # 对于字典，for循环只能拿到key
    print(i,dic[i])   # 按key 索引取值

3.range

print(list(range(10)))
# [0,1,2,...,9]
for i in range(10):
    print(i)

range 步长

4.for + break

中断

for i in range(50,100,3):
    if i == 50:
        break
    print(i)

5.for+continue

跳过

for i in range(50,100,3):
    if i == 50:
        continue
    print(i)

6.for + else

for循环不被break终止就执行else下的代码

for i in range(50,100,3):
    if i == 50:
        continue
    print(i)

print 打印之后又end可以更换结尾

import time

time .sleep

数字类型内置方法

整型

1.作用： 年龄

2.定义方式：int

3.使用方法：+-/* % //

5.有序 or 无序

有索引的就有序，无索引的就无序。

6.可变 or 不可变

值变ID不变就可变，值变ID变叫不可变

整型不可变

x=1
print(id(x))
x=10
print(id(x))

id 地址变化，可见x重新创建了新的地址。

浮点型

1.作用： 薪资

2.定义方式：float

3.使用方法：+-*/%

4.有序 or 无序：压根没有有序无序一说

5.可变 or 不可变 ：不可变

id 地址变化，可见x重新创建了新的地址。

字符串

1.作用

描述姓名

2.作用

单引号/双引号/三单引号/三双引号

3.使用方法

1.索引

# 1. 索引
# 左    右
s = 'nick handsome'
#    01234567
#              -2-1
print(s[1])

2.索引切片

print(s[0:4])  # 顾头不顾尾
print(s[0:4:2])  # 2表示步长，隔一个取一个
print(1, s[4:0:-1])  # +从左到右，-表示从右到左
print(1, s[2:])  # 左边的不写取到最左边，右边的不写取到最右边

3.for 循环

for i in s:
    print(4,i)

4.成员运算

s = 'nick handsome'
print('nick' in s)
print('nick1' not in s)  # True

5.strip (默认去除两端的空格)

可以指定去除的字符，但必须是两端的字符。也可去除多个字符

s1 = 'a  nick   ******'
# print(s1.strip())
print(s1.strip(' kc*'))  # 可以乱序，但是不能没有

6.split（切割）

按照特定的字符切割字符串，得到列表

s2 = 'nick|123658|180|140'
print(s2.split('|'))  # 按照|切割字符串，得到的是一个列表

7.len （长度）

s = 'nick handsome'
print(len(s))
# 13

需要掌握

1.lstrip&rstrip

去除左右两端特定符号

s3 = '**nick**'
print(s3.lstrip('*'))   # nick**
print(s3.rstrip('*'))   # **nick

2.lower&upper

输出字符串的大写或小写

s3 = 'Nick'
print(s3.lower())  # 小写    nick
print(s3.upper())  # 大写   NICK

3.startswith & endswith

判断以..开始&结束，输出布尔值

s4 = 'nick handsome'
print(s4.startswith('nick'))  # 以。。。开始  True
print(s4.endswith('some'))  # 以。。。结束   True

4.rsplit

从右侧以特定符号开始切割

s = 'nick|handsome|180|140|'
print(s.split('|',1))   #['nick', 'handsome|180|140|']
# split 是默认从左开始，输入1切割一次
print(s.rsplit('|',1))  # 从右切割  ['nick|handsome|180|140', '']

5.join

使用特定符号（*+-）拼接列表中的每一个元素输出字符串

s = 'nick|handsome|180|140'
lt = s.split('|')
print(lt)
print('*'.join(lt))  # 使用*拼接列表内的每一个元素
#  输出 nick*handsome*180*140

6.replace

将特定的字符替换成新的字符串

s = 'nick handsome'
s = s.replace('nick','nick chen')
print(s)
#  nick chen handsome

7.isdigit / isalpha

判断字符串是否为纯数字 isdigit

判断字符串是否为纯字符 isalpha

 # 使用于判断输入密码是否纯数字
pwd = input('请输入你的密码：')
if not pwd.isdigit():
    print('请输入纯数字')

了解

find|rfind|index|rindex|count

1.find

找索引

s = 'nick handsome'
print(s.find('h'))  # 找索引
print(s.find('h',6，10))  # -1表示没找到  从索引6-10

2.rfind

从右到左找

print(s.rfind('h',6,10))

3.index

也是找索引，但是没找到会直接报错

print(s.index('h'))
# print(s.index('sadf'))  # 找不到报错
# print(s.find('sadf'))  # 找不到返回-1

4.rindex

从右开始找

5.count

计数

s = 'aaaaacccc'
print(s.count('a'))
# 输出 5

center|ljust|rjust|zfill

1.center 居中打印

ljust 居左

rjust居右

s = 'nick'
print(s.center(50,'*')) # 居中
# ***********************nick***********************
print(s.ljust(50,'*'))  # 居左
# nick**********************************************
print(s.rjust(50,'*'))  # 居右
# **********************************************nick

zfill

默认用0填充至指定长度

s = '111'
print(s.zfill(8))
#  00000111

expandtabs

扩展缩进的，将默认的缩进更改为指定长度缩进

/n 换行

/t 缩进

s = 'a\t\t\t\ta'
print(s)
#  a                a
print(s.expandtabs(18))
#  a                                                      a

captalize|swapcase|title

captalize

让首字母大写，会让字符串中间的大写变成小写

s = 'nickNick handsome'
print(s.capitalize())  # 首字母大写
#  Nicknick handsome

swapcase

转化大小写（大小写字母的反转）

s = 'nickNick handsome'
print(s.swapcase())
#  NICKnICK HANDSOME  （大写变为小写，小写变大写）

title

每个单词的首字母大写

s = 'nickNick handsome'
print(s.title())  # 每个单词的首字母大写
#  Nicknick Handsome

is系列：有兴趣看一看，没兴趣算了

4.有序or无序：

有序

5.可变or不可变：

不可变

s = 'nick'
print(id(s))
s += 'nick'
print(id(s))
id 变化，字符串是不可变的

列表内置方法

1.作用

存储多个值

2.定义方式

[]用逗号，隔开多个元素

3.使用方法

优先掌握

1.索引取值

lt = [1, 2, 3, 4]
print(lt[1])
# 2

2.索引修改值

lt[1] = 3
print(lt)
# 输出 [1, 3, 3, 4]

3.切片

lt = [1, 3, 3, 4]
print(lt[:])   # 全部取出来  [1, 3, 3, 4]
print(lt[1:2])  # 取出1   [3]
print(lt[1:4:2])  # 取出123 步长为2 就是13 [3, 4]

4.for 循环

for i in lt:
    print(i)

5.成员运算

print(1 in lt)   # True
print(5 in lt)  # False

6.len(长度)

print(len(lt))

7.append（）

增加值

# 先添加 再打印
lt.append(5)
print(lt)

8.del

删除指定序列的元素

lt = [1, 3, 3, 4]
del lt[0]     
print(lt)

需要掌握

1.insert

在指定序号的前面插入

lt = [1, 2, 3, 4, 5]
lt.insert(0, 0)  # 往前插入
print(lt)
# [0, 1, 2, 3, 4, 5]

2.pop

按照索引删除值

lt = [11, 22, 33, 44, 55]
lt.pop(0)
print(lt)
#  [22, 33, 44, 55]

3.remove

按照对象值删除指定

lt = [11, 22, 33, 44, 55]
lt.remove(22)
print(lt)
# [33, 44, 55]

4.count

计数：记录某值出现的次数

lt = [11, 11, 11, 22]
print(lt.count(11))
 #  3

5.index

寻找值的索引，找到了便返回

lt = [11, 11, 11, 22]
print(lt.index(11))  # 找到了就返回 (不会继续找)
#  0

6.clear

清空列表

lt = [1, 2, 2, 3]
lt.clear()
print(lt)
  # []

7.copy

拷贝列表

lt = [1, 2, 3, 4]
lt1 = lt.copy()
print(lt1)
# [1, 2, 3, 4]

8.extend

扩展列表

lt1 = [1, 2, 34]
lt2 = [1, 1, 2, ]
lt1.extend(lt2)
print(lt1)
#  [1, 2, 34, 1, 1, 2]

9.reverse

反转列表

lt = [1, 2, 3, 4]
lt.reverse()
print(lt)
#  [4, 3, 2, 1]

10.sort

对列表进行排序

lt = [2, 3, 1, 0, 4]
lt.sort()
print(lt)
# 进行排序
lt.sort(reverse=True) （进行倒叙）
print(lt)
# [4, 3, 2, 1, 0]

# 今天整理，未来写项目的遇到了，证明有用，没遇到证明没用，不要全记住

4.有序 or 无序

有序

5.可变 or 不可变

可变

lt = [1, 2, 3]
print(id(lt))
lt.append(4)
print(id(lt))
id 相等 可变