数字类型/字符串类型/列表

目录

• 1.流程控制之for循环
• 2. 数据类型的内置方法
  • 1. 数字类型（整型（int） 浮点型（float））
    • （1）作用
    • （2）定义方式
    • （4）可变 or 不可变
    • （5）使用方法
  • 2. 字符串内置方法（str）
    • （1）作用
    • （2）定义方式
    • （5）使用方法
  • 3. 列表内置方法（list）
    • （1）作用
    • （2）定义方式
    • （3）有序 or 无序
    • （4）可变 or 不可变
    • （5）使用方法

1|01.流程控制之for循环

• while循环：可以循环一切事物

• for 循环： 提供了一种手段，不依赖索引取值

for 变量名(会拿到容器类元素的每一个值,没有了就结束循环) in 容器类元素:    
print(变量名)
for i in dic:  # 对于字典，for循环只能拿到key

• for + continue

for i in range(50,101,3):  # 顾头不顾尾,2表示步长
    if i == 53:         
    continue  # 跳出本次循环，不执行下面的代码
    print(i)

• for + break

  for i in range(50,101,3):  # 顾头不顾尾,2表示步长
      if i == 53:
          break  # 中断循环
      print(i)
  

• for + else

  for + else：for循环不被break提前终止就执行else下的代码，否则不执行
  for i in range(50,101,3):
     if i == 1000:
          break
      print(i)
  else:
      print('如果没有被break终止我就打印')
  

2|02. 数据类型的内置方法

2|11. 数字类型（整型（int） 浮点型（float））

1|0（1）作用

• 描述年龄/id

1|0（2）定义方式

x = 10

### （3）有序 or 无序

```python
(有索引的就有序，无索引的就无序)
所以数字类型压根就没有有序无序一说

1|0（4）可变 or 不可变

​ （值变id不变叫可变，值变id变叫不可变）

• 数字类型：  不可变
  

1|0（5）使用方法

• + - * / % // ** < <= > >= == !=
  

2|22. 字符串内置方法（str）

1|0（1）作用

• 描述姓名/性别等

1|0（2）定义方式

x = 'sss'
x = "sss"
x = '''sss''' # 可换行
x = """sss""" # 可换行

### （3）有序 or 无序

​		**有序**

### （4）可变 or 不可变

​	**==（值变id不变叫可变，值变id变叫不可变）==**

```python
字符串： 不可变

1|0（5）使用方法

•  ****************优先掌握（今天就得掌握）*********************
  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. 成员运算
  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长度
  s1 = 'nick handsome'
  print(len(s1))
  
   **********************需要掌握**************************
  
  1. lstrip & rstrip
  s3 = '**nick**'
  print(s3.lstrip('*'))
  print(s3.rstrip('*'))
  
  2. lower & upper
  s3 = 'Nick'
  print(s3.lower())  # 小写
  print(s3.upper())  # 大写
  
  3. startswith & endswith
  s4 = 'nick handsome'
  print(s4.startswith('nick'))  # 以。。。开始
  print(s4.endswith('some'))  # 以。。。结束
  
  4. rsplit
  s = 'nick|handsome|180|140|'
  #    01234
  # print('range(len(s))',range(len(s)))
  # lt = []
  # ind = -1
  # for i in range(len(s)):
  #     if s[i] == '|':
  #         lt.append(s[ind+1:i])
  #         ind = i # ind = 4
  #
  # print('lt', lt)
  
  print(s.split('|',1))
  print(s.rsplit('|',1))  # 从右切割
  
  5. join
  s = 'nick|handsome|180|140'
  lt = s.split('|')
  print(lt)
  # 用*拼接列表内的每一个元素
  # new_s = ''
  # for i in lt:
  #     i += '*'
  #     new_s += i
  # print(new_s)
  print('*'.join(lt))  # 使用*拼接列表内的每一个元素
  
  6. replace
  s = 'nick handsome'
  s = s.replace('nick','nick chen')
  print(s)
  
  7. isdigit/isalpha
  s = 'a123123'
  print(s.isdigit())  # 判断字符串内字符是否都为数字
  s = 'askdlfj234'
  print(s.isalpha())
  
  
  # pwd = input('请输入你的密码：')
  # if not pwd.isdigit():
  #     print('请输入纯数字')
  
  ****************了解（看到能够想起来就行）***************
  
  1. find|rfind|index|rindex|count
  s = 'nick handsome'
  print(s.find('h'))  # 找索引,-1表示没找到
  print(s.rfind('h',6,10))
  
  print(s.index('h'))
  # print(s.index('sadf'))  # 找不到报错
  # print(s.find('sadf'))  # 找不到返回-1
  
  s = 'aaaaacccc'
  print(s.count('a'))
  
  2. center|ljust|rjust|zfill
  s = 'nick'
  print(s.center(50,'*')) # 居中
  print(s.ljust(50,'*'))
  print(s.rjust(50,'*'))
  s = '111'
  print(s.zfill(8))
  
  3. expandtabs
  # \n 换行
  # \t 缩进
  s = 'a\t\t\t\ta'
  print(s)
  print(s.expandtabs(18))
  
  4. captalize|swapcase|title
  s = 'nickNick handsome'
  print(s.capitalize())  # 首字母大写
  print(s.swapcase())
  print(s.title())  # 每个单词的首字母大写
  

2|33. 列表内置方法（list）

1|0（1）作用

• 描述年龄/id

1|0（2）定义方式

[]用逗号隔开多个元素

lis = [1,2,3,4,'ss',[5,6,'jj',8]]

1|0（3）有序 or 无序

(有索引的就有序，无索引的就无序)

列表 ： 有序

1|0（4）可变 or 不可变

（值变id不变叫可变，值变id变叫不可变）

• 列表 ：  可变
  

1|0（5）使用方法

 优先掌握

# 1. 索引取值/索引修改值
lt = [1, 2, 3, 4]
print(lt[1])
# lt[1] = 3
# print(lt)

# 2. 切片
print(lt[:])
print(lt[1:2])
print(lt[1:4:2])

# 3. for循环
for i in lt:
    print(i ** 2)

# 4. 成员运算
print(1 in lt)
print(5 in lt)

# 5. len
print(len(lt))

# 6. append()
lt.append(5)
print(lt)

# 7. del删除
print(lt)
# del lt[0]
# print(lt)

需要掌握

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

# 2. pop:按照索引删除值
lt = [11, 22, 33, 44, 55]
lt.pop(0)
print(lt)

# 3. remove：按照值删除值
lt.remove(22)
print(lt)

# 4. count：计数
lt = [11, 11, 11, 22]
print(lt.count(11))

# 5. index：寻找值的索引
print(lt.index(11))  # 找到了就返回

# 6. clear：清空列表
lt = [1, 2, 2, 3]
lt.clear()
print(lt)

# 7. copy：拷贝列表
lt = [1, 2, 3, 4]
lt1 = lt.copy()
print(lt1)

# 8. extend: 扩展列表
lt1 = [1, 2, 34]
lt2 = [1, 1, 2, ]
lt1.extend(lt2)
print(lt1)

# 9. reverse：反转列表
lt = [1, 2, 3, 4]
lt.reverse()
print(lt)

# 10. sort
lt = [2, 3, 1, 0, 4]
lt.sort(reverse=True)
print(lt)

__EOF__

本文作者：BigSun丶
本文链接：https://www.cnblogs.com/Mcoming/p/11512696.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！