day06-for循环补充,可变与不可变类型,数字,字符串和列表的使用

今日内容:

for 循环补充

for + range()

语法:range(start_num=0, end_num, step=1)

• 其中的start_num为起始的数值 默认等于0
• end_num 为 结束数值
• step 为步长(即每次取值的间隔) 默认等于1
• 注意:该方法顾头不顾尾

在python2进行range()操作

C:Users>python2
Python 2.7.16 (v2.7.16:413a49145e, Mar  4 2019, 01:37:19) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(3,10)
[3, 4, 5, 6, 7, 8, 9]
>>> range(3,10,2)
[3, 5, 7, 9]
>>> range(3,10,-2)
[]
>>> range(10,3,-2)
[10, 8, 6, 4]

python3在交互下进行range()

C:Users菩萨>python3
Python 3.7.4 (tags/v3.7.4:e09359112e, Jul  8 2019, 20:34:20) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> range(10)
range(0, 10)  # 返回的是一个创建列表的对象

在pycharm中进行案例示范

range(0, 10)   
t_obj = range(10)
print(t_obj, type(t_obj))  # 返回的结果 range(0, 10) <class 'range'>

例子: range()方法的三种搭配

range(10)
range(0, 10)
range(0, 10, 1)  # 三种方法返回的值是一样的

for + enumerate

意义: 取一个可迭代对象的下标(即索引)和值对应的关系,返回的是一个元组(元组是一个值不可变额列表)

obj为一个可迭代的对象(例如:列表和字典,一般搭配列表使用)

语法: for index, value in enumerate(obj):

• 其中index表示的是遍历对象的值对应的索引
• value表示的是遍历对象的值
• obj为可迭代对象

例子: 取出下方列表中的值以及对应的索引

user_infos = ['jkey', 18, 'male', 'eat']
for user_info in user_infos:
    print(user_info)   # ====> 'jkey 18 male eat'

for index, user_info in enumerate(user_infos):
    print(index, user_info)  # ====> '0 jkey 1 18 2 male 3 eat'

不可变类型与可变类型

不可变类型

概念: 不可变数据类型在第一次声明赋值声明的时候, 会在内存中开辟一块空间, 用来存放这个变量被赋的值, 而这个变量实际上存储的, 并不是被赋予的这个值, 而是存放这个值所在空间的内存地址, 通过这个地址, 变量就可以在内存中取出数据了. 所谓不可变就是说, 我们不能改变这个数据在内存中的值, 所以当我们改变这个变量的赋值时, 只是在内存中重新开辟了一块空间, 将这一条新的数据存放在这一个新的内存地址里, 而原来的那个变量就不在引用原数据的内存地址而转为引用新数据的内存地址了.

可变类型

概念: 结合不可变数据类型，可变数据类型就很好理解来，可变数据类型是指变量所指向的内存地址处的值是可以被改变的,即id不变,值改变

一句话区分可变与不可变:

• 1、可变：值变，id不变。可变==不可hash
• 2、不可变：值变，id就变。不可变==可hash

小技巧:一般单个值的数据类型都是不可变的,多个值的数据类型一般为可变的,但元组是不可变的

数字类型

int类型的 基本使用

1.用途:记录年龄,个数,号码,等级...

2.定义方式: int()

age = 18  # =====> age = int(18)  
print(type(age)))  # int() 为工厂函数,所以的整型都是该函数创建的

int 数据类型转换: 可以把纯数字的字符串转化成整型

res = int('  18   ')
print(res, type(res))
# 需要注意的是int内的字符串必须为一个纯数字组成的,而且数字之间不能有空格,俩边的空格,int()方法以及给你优化了

float类型的基本使用

1.用途:记录薪资,身高,体重

2.定义方式: float()

salary = 3.1  # ===> salary = float(3.1)
res = float('  1.8   ')
print(res, type(res))
# 需要注意的是float内的字符串必须为一个小数组成的,而且数字和小数点之间不能有空格,俩边的空格,float()方法以及给你优化了

了解:long类型.进制转换,复数

1.long 类型 在python2中 数字中的类型 6L === > 类型就是long

2.10进制和二进制,八进制,十六进制的转化

print(bin(11))  # 二进制
print(oct(11))  # 八进制
print(hex(11))  # 十六进制

3.复数

x = 1 - 2j
print(x, type(x)) 
print(x.real)  # 1.0
print(x.imag)  # -2.0

字符串的基本使用

1.用途:记录描述性质的状态

2.定义方式:在"",'','''''',"""""",内保护一串字符

msg = 'jkey'  # msg = str("jkey")
print(msg, type(msg))

注意:
1.上述引号定义出来的都是str类型,没有类型区别
2.三引号表示多行,也可以表示注释
3.

数据类型转换

l = str([1, 2, 3])
print(l, type(l))  # 此时的l内的元素都是字符  ====>[1, 2, 3] <class 'str'>

补充:俩种取消转义的方法

print('abc
ddd')  # ====> abc
                        #  ddd
# 俩种取消转义的方法
print(r'abc
ddd')  # 方法1:字符串前面加r表示该字符串都是原生字符,该表示什么还是表示什么 ==> abc
ddd
print('abc\nddd')  # 方法2:在需要取消转义的地方再加上一个 取消后面的的特殊意义 ==> abc
ddd

file_path = r'E:xifu.js'
file_path1 = 'E:\xifu.js'
print(file_path, file_path1)  # ===> E:xifu.js E:xifu.js

优先掌握的操作：

1、按索引取值(正向取+反向取) ：只能取

• 功能:在字符串中取字符串

• 语法: str_obj[index]

  • 其中str_obj表示一个字符串对象
  • index表示字符串中的字符对应的索引

• 返回的是一个新的字符串

案例:

str_func = 'my function is 按索引取值'
res_value = str_func[-1]  # 根据索引 反向取值
res_value1 = str_func[0]  # 根据索引正向取值
print(res_value, res_value1, type(res_value))  # 能取出来,并且返回一个字符串
print(str_func)  # 但不会改变原来字符串的值

2、切片(顾头不顾尾，步长)

• 功能:在字符串中copy字符

• 语法: str_obj[start_index:end_index:step]

  • 其中start_index表示切片的开始索引在字符串中位置,默认从开头第一个字符开始切片
  • end_index表示的是切片时的结束位置的索引,默认为最后一个字符
  • step表示的切片的间隔,默认为1,可以为负数

• 返回的是一个切片后的,新的字符串

案例:

str_func = '我的功能是切片,并且顾头不顾尾'
# 根据索引切片,拷贝其中范围内的字符串,返回一个新的字符串
res_value = str_func[0:15:1]  # 其中的0表示的是切片时的起始位置,即起始的字符,15表示切片切到的结束位置的字符索引位置,1表示的是取字符的间隔
res_value2 = str_func[::]  # 等同于上方的切片操作,默认就是从头切到位,步长为1
# 当你想反着取时,可以这样
res_value3 = str_func[::-1]  # 搭配玩法可以自己尝试
print(res_value, res_value2, res_value3)

3、长度len

• 功能:计算出字符串的个数

• 语法: len(obj)

  • obj 表示一段字符串(可迭代对象即可)

• 返回的是一个 个数(字符串的长度)

案例:

str_func = '我是一段字符串'
str_count = len(str_func)  # 返回的是一个整数
print(str_count)  # ===>  7

4、成员运算in和not in

• 功能:判断一个字符是否在另一个字符串中
• 语法:str in other_str 或者 str not in other_str
• 返回的是一个布尔值

案例:

str_field = '我是一组字符串,我里面有名字jkey'
bool_value = ('jkey' in str_field)  # 判断字符串是否在另外一个字符串里面
print(bool_value)  # 返回结果为一个布尔值 ===> True
print('liu' not in str_field)  # not in 判断一个字符串是否不在另外一个字符串中 ===> True

5.移除空白strip

• 功能:移除字符串中的空白字符(或其他字符)
• 语法: str_obj.strip('str')
  • 'str' 表示的是去除的字符,默认为空,去空
• 其底层是将()括号内的字符一一与前面调用的字符串内的字符从开头匹配,匹配上了就去除,没匹配上就结束,然后从末尾向前一一匹配匹配上了就去除,没匹配上就结束
• 返回的是一个去除字符后的新的字符串

例1:

str_field = '    我俩边有很多空格     '
print(str_field)  # '    我俩边有很多空格     '
new_str = str_field.strip()  # .strip() 将俩边的空白格去除了,
print(new_str)  # 返回一个新的字符串 ===> "我俩边有很多空格"

例子2:将字符串str_field1俩边的 "+-*%_ "全部去除

str_field1 = "+-*% + - hello  +-*% + -  "
str_field1 = str_field1.strip('+-*%_ ')  # 将str_field1去除字符串"+-*%_ "的新的字符串绑定回str_field1
print(str_field1)

6.切分split

• 功能:. 将一段字符串按照指定的格式分成多个字符串,每个字符串都是切分后列表中的元素
• 语法: split(sep,maxsplit)
  • sep表示的特殊的字符(按该字符切分)
  • maxsplit表示的是切分的次数 默认为 -1全部切分
• 返回的是一个特定的列表

案例:

str_field = '我是,一段,字符串'
new_str = str_field.split(',')  # 根据 ',' 将 str_field 分为 ['我是', '一段', '字符串'] 这样的列表
print(new_str)  # ===> ['我是', '一段', '字符串']

7.字符串和循环

• 功能:将字符串中的每个字符遍历出来
• 语法: for str_num in str_obj:
  • str_num 为每个字符的变量名,取一个字符就将上一次的变量名指向的值改变了,但是是一个新的内存空间
  • str_obj 为要遍历的字符串
• 返回的是一个个的字符

str_field = 'hello world'
for str_1 in str_field:
    print(str_1, end='')  # 循环打印出字符串中的每个字符,打印取消换行

需要掌握的操作

1、strip,lstrip,rstrip

• 功能:
  • strip()表示将俩边都去除,
  • lstrip()表示的是将字符串左边的去除
  • rstrip()表示将字符串右边的去除
• 语法:str_obj.strip()/str_obj.lstrip()/str_obj.rstrip()
• 返回的是一个新的字符串

案例:

str_field = '   将空格去除   '
print(str_field.strip())  # ===> "将空格去除"
print(str_field.lstrip())  # ===> "将空格去除   "
print(str_field.rstrip())  # ===> "   将空格去除"

2、lower,upper

• 功能
  • lower() 将字符串全变为小写 返回一个新的字符串
  • upper() 将字符串全变为大写 返回一个新的字符串
• 语法:str_obj.lower()/str_obj.upper()
• 返回的是一个新的字符串

案例:

str_field = 'Hello'
print(str_field.lower())  # ===> hello
print(str_field.upper())  # ===> HELLO

3、startswith,endswith

• 功能:
  • startswith() 判断字符串以什么字符开头,返回一个布尔值
  • endswith() 判断字符串以什么字符结尾,返回一个布尔值
• 语法startswith(self, prefix, start=None, end=None) / endswith(self, prefix, start=None,end=None)
  • prefix 表示的是要判断的字符
  • start,end表示字符串的判断范围,默认为None表示开头到结尾
• 返回的是一个布尔值

案例:

str_field = 'Hello'
print(str_field.startswith('h'))  # ===> False
print(str_field.endswith('o'))  # ====> True

4、format 字符串格式化输出

• 功能:Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
  基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

format的三种玩法

# 玩法1:按照关键字传参
name = 'jkey'
age = 18
user_info = 'my name is {name} my age is {age}'.format(name=name, age=age)
print(user_info)

# 玩法二: 根据索引传值
user_info_1 = 'my name is {0} my age is {1}'.format(name, age)
print(user_info_1)

# 玩法三: 根据 ** 传字典
user_info_2 = 'my name is {name1} my age is {age1}'.format(**{"name1": 'jkey', 'age1': 18})
print(user_info_2)

5、split,rsplit

• 功能:split() 表示从左往右根据关键字符切片成列表, rsplit()表示从右往左 根据关键字符切片成列表
• 语法:str_obj.split(start_index,end_index,step)/str_obj.rsplit(start_index,end_index,step)
• 返回的是一个切片后的列表

案例:

str_field = 'jkey,123,1000'
new_str = str_field.split(',', 1)  # 按照","从左往右并且只切分一次,返回的结果为['jkey', '123,1000']
new_str2 = str_field.rsplit(',', 1)  # 按照","从右往左并且只切分一次,返回的结果为['jkey,123', '1000']
print(new_str, new_str2)  # ['jkey', '123,1000'] ['jkey,123', '1000']

6、join

• 功能:''.join() 将一个列表内的元素按照指定的字符拼接成一个字符串(默认无缝拼接)
• 语法:'s'.join(list_obj)
  • s表示的是拼接符
  • list_obj 表示拼接的列表对象
• 返回的是一个拼接后的字符串

案例:

str_list = ['h', 'e', 'l', 'l', 'o']
res_str = ''.join(str_list)  # 返回的是一个 "hello" 字符串
print(res_str, type(res_str))  # ===> hello <class 'str'>

7、replace

• 功能:替换,将字符串中的字符替换成一个新的字符
• 语法:replace(old_str,new_str,count)
  • old_str 表示的是 原字符
  • new_str 表示的是 更改成的 字符
  • count 表示更改的个数,默认为更改全部

案例:

str_field = 'my name is JKey JKey'
print(str_field.replace("JKey", "liu", 1))  # my name is liu JKey
print(str_field)  # ===> my name is JKey JKey

8、isdigit

• 功能:表示的是判断一个字符串是否为一个纯数字的字符组成,
• 语法:str_obj.isdigit()
• 返回的是一个布尔值

例如:猜年龄

while True:
    inp_age = input('请输入您猜的年龄为>>>:').strip()
    if inp_age.isdigit():  # 判断用户输入的字符串是否为全数字,不是就不执行下面的子代码
        inp_age = int(inp_age)
        if inp_age > 18:
            print('没那么老')
        elif inp_age < 18:
            print('没那么小')
        else:
            print('猜对了')
            break
    else:
        print('请输入数字')

了解方法:

find() , rfind, index(), rindex()

• 功能:上面的方法都表示返回一个字符在大字符中第一次出现的位置(即下标,索引),不带r的表示从左往右查找匹配,带r的表示从右往左查找匹配
• 语法:str_obj.find('strs')/str_obj.rfind('strs')/str_obj.index('strs')/str_obj.rindex('strs')
• 返回的是索引

案例:

msg = 'hello world'
print(msg.find('el'))  # 1
print(msg.rfind('l'))  # 9
print(msg.index('el'))  # 1
print(msg.rindex('l'))  # 9

print(msg.find('xxx'))  # 查找不到的时候返回-1
print(msg.index('xxx'))  # 查找不到的时候报错 ===> ValueError: substring not found

center, ljust, rjust, zfill

• 功能:字符串格式化输出
• 语法:str_obj.center()/str_obj.ljust/str_obj.rjust/str_obj.zfill

案例:

print(msg.center(50, '-'))  # ===> -------------------hello world--------------------
print(msg.ljust(50, '-'))  # ===> hello world---------------------------------------
print(msg.rjust(50, '-'))  # ===> ---------------------------------------hello world
print(msg.zfill(50))  # 等同于msg.rjust(50, '0')  # 000000000000000000000000000000000000000hello world

captalize,swapcase,title

• 功能:针对字母的字符串所赋予的功能

案例

print(msg.capitalize())  # 返回的是开头的字母的大写的字符串  ===> Hello world
print(msg.swapcase())  # 返回的是和字符串中的字母大小写相反的字符串  ====> HELLO WORLD
print(msg.title())  # 返回的是字符串中的单词开头大写的字符串 ====> Hello World

is数字系列

在python3中isdigit() isdecimal() isnumeric() 方法判断的是一个字符串是否都是数字组成的,返回True和False,其中的数字分为下面四种

num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中无需加u就是unicode
num3 = '四'  # 中文数字
num4 = 'Ⅳ'  # 罗马数字

案例:

# bytes、unicode
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

is其他方法

name = 'JKey123'
print(name.isalpha())  # False  判断字符串是否都是字母
print(name.isalnum())  # True  判断字符串是否由数字和字母组成
print(name.isascii())  # True  判断字符串是否全是ASCII表上的

print(name.islower())  # False  判断字符串是否全是小写字母
print(name.isupper())  # False  判断字符串是否全是大写字母
print(name.isspace())  # False  判断字符串是否为全空格
print(name.istitle())  # False  判断所有单词都是首字母大写，像标题

字符串是一个不可变的存一个值的,有序的数据类型

列表--list()

作用：多个装备，多个爱好，多门课程，多个女朋友等

定义：[]内可以有多个任意类型的值，逗号分隔 或 list(x)方法定义定义的,其中x为可迭代对象

l=list('abc')  # 等同于 --- >l = ['a', 'b', 'c']
# list数据类型转换,把可迭代的类型转成列表,可以被for循环遍历的类型都是可迭代的
res = list('hello') 
res2 = list({'k1': 111, 'k2': 222}) 
print(res, res2)  # ===> ['h', 'e', 'l', 'l', 'o'] ['k1', 'k2']
# print(list(1000))  # 不可转换,1000为不可迭代的数据类型
print(list(range(100))) # ===> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,...,99]

优先掌握的操作：

1、按索引存取值(正向存取+反向存取)：即可存也可以取

案例:

li = [1, 2, 3]
li[0] = 6  # 可以根据列表的索引将对应的值更改  1 ---> 6
print(li)  # [1, 2, 3] =====> [6, 2, 3]

2、切片(顾头不顾尾，步长)

• 功能:将一个列表按照索引的起始位置,结束位置以及步长 切片出想要取出的元素值列表
• 语法:list[start_li:end_li:step]
  • start_li表示在列表中开始的位置,end_li表示在列表中结束的位置,step 表示取值的间隔
  • 其中start_li默认值为开头第一个,end_li默认值为末尾第一个,step默认为1
• 返回的是一个新的列表

案例:

num_list = [11, 22, 33, 44, 55]
copy_num_list = num_list[:]  # num_list[:] 表示切片的起始位置为0,结束的位置为最后一个元素,步长为1
print(copy_num_list)  # ====> [11, 22, 33, 44, 55]
print(num_list)  # ====> [11, 22, 33, 44, 55]

3、长度 len()

• 功能:计算一个列表的值的个数

• 语法:len(list_obj)

  • 表示计算一个列list_表(list_obj为 可迭代对象)的长度 返回的是 值的个数

• 返回的是一个整数 值

案例:

num_list = [1, 2, 3, 4, 5]
print(len(num_list))  # ===> 5

4、成员运算in和not in

案例:

str_list = ['JKey', 'liu', 'song']
print('liu' in str_list)  # in 表示判断一个值是否在列表当中,返回布尔值  ===> True
print('zhao' not in str_list)  # not in 表示判断一个值是否不在列表当中,返回布尔值  ===> True

5、追加

append()

• 功能: 在列表中追加一个值
• list_obj.append(value)
  • value可以是任何数据类型
• 返回一个None

案例:

int_list = [11, 22, 33, 44, 55]
print(int_list)  # ====> [11, 22, 33, 44, 55]
int_list.append(66)  # 在列表中追加一个值66放到末尾
print(int_list)  # ====> [11, 22, 33, 44, 55, 66]
int_list.append([777, 888])  # 在列表中追加一个值[777, 888]的列表放到末尾
print(int_list)  # ====> [11, 22, 33, 44, 55, 66, [777, 888]]
res = int_list.append(1)
print(res)  # ===> None

insert()

• 功能:.insert(value) 在一个列表中插入一个值,value可以是任何数据类型
• 语法:list_obj..insert(\__index=0, __object=00)
  • __index表示的是插入的位置,0就表示在最前面插入,__object表示的是插入的值
• 返回的是None

案例:

int_list1 = [11, 22, 33, 44, 55]
print(int_list1)  # ===> [11, 22, 33, 44, 55]
int_list1.insert(0, 00)  # 在列表中的索引0前面插入一个00的值
print(int_list1)  # ====> [0, 11, 22, 33, 44, 55]
res = int_list1.insert(0, 123)
print(res)  # ===> None

6、删除

del l[index]

• 功能:del 表示将列表中的值直接删掉
• 语法:del list_obj[index]
• 没有返回值,接收返回值会报语法错误

案例:

int_list = [11, 22, 33, 44, 55]
del int_list[2]  # 将列表中的第三个值删掉
print(int_list)  # ====>[11, 22, 44, 55]

remove()

• 功能:表示将列表中的值直接删掉
• 语法:list_obj.remove(list_value)
  • list_value表示的是列表中的值
• 返回值为一个None

案例:

int_list = [11, 22, 33, 44, 55]
int_list.remove(33)  # 将列表中的值为33的值删除,直接删除,没有返回值
print(int_list)  # =====> [11, 22, 44, 55]
print(int_list.remove(22))  # ====> None

li.pop()

• 功能:将列表中的取值,并在源列表中删除掉取出的值
• 语法:list_obj.pop(index)
• 返回的是列表中索引对应的值

案例:

res = list.pop(index) 返回的是取出来的值,数据类型不变
int_list = [11, 22, 33, 44, 55]
res_int = int_list.pop(0)  # 将列表中的索引为0对应的值在列表中拿出来,并绑定给res_int这个变量名
print(res_int, type(res_int))  # ====> 11 <class 'int'>
print(int_list)  # ====> [22, 33, 44, 55]

7、列表和for循环

• 功能:遍历出列表中的每一个元素的值
• 语法: for list_value in list_obj:

int_list = [11, 22, 33, 44, 55]
for int_num in int_list:  # 会将列表中的值循环取,取干净就退出循环
    print(int_num)  # ====> '11 22 33 44 55'