可变不可变

# 如果值改变，但是内存地址不变，证明就是在改变原值，即原值可变
# 如果值改变，但是内存地址也变了，证明不是在改变原值，而是产生了新的值，即原值不可变

x = 10
print(id(x))       
x = 11                      # 内存地址发生变化，原值不可变
print(id(x))


l = [111, 222, 333]
print(id(l))
l[0] = 666                  # 内存地址无变化，原值可变
print(id(l))

整型的基本使用

===================================int基本使用======================================
1、用途
将字符串数字转换成整型
2、定义方式
age = 18                # age = int(18)
int数据类型转换
res = int("    18    ")
print(res,type(res))        # res int
3、常用操作+内置的方法
算数运算+比较运算

==================================该类型总结========================================
# 存一个值
# 不可变

浮点型的基本使用

=================================float基本使用======================================
1、用途

2、定义方式
salary = 3.33  # salary = float(3.33)

float数据类型转换
res = float("    1.8    ")
print(res,type(res))

3、常用操作+内置的方法
算数运算+比较运算

=====================================该类型总结======================================
# 存一个值
# 不可变

字符串的基本使用

  =================================str基本使用======================================
1、用途

2、定义方式
name = "egon"  # name = str("egon")

str数据类型转换：可以把任意类型都转换成字符串类型
res = str([1,2,3])
print(res,type(res))  # "[1,2,3]"

3、常用操作+内置的方法
3.1 优先掌握的操作：
(1)、按索引取值(正向取+反向取) ：只能取

msg = 'hello world'
print(msg[4])
print(msg[5])
print(msg[-1])


(2)、切片(顾头不顾尾，步长)：从一个大字符串中拷贝出一个子字符串
msg = 'hello world'
res = msg[1:5:2]  # 1 3
res = msg[1:5]  # 1234
res = msg[1:]  # ello word
res = msg[:]  # hello word
res = msg[-1:-4:-1]  # dlr
res = msg[-1::-1]  # 将字符串颠倒
res = msg[::-1]  # 将字符串颠倒


(3)、长度len
msg = 'hello world'
print(len(msg))   # 11个字符

(4)、成员运算in和not in
msg = 'hello world'
print('el' in msg)    # true
print('el' not in msg)   # false
print(not 'el' in msg)   # false

(5)、移除空白strip
name = '       eg on       '
print(name.strip("条件  不写默认空格 可输入多个条件"))    # eg on   删除两边条件字符

x = '*****eg on****'
print(x.replace("条件 不写默认空格",'所有条件更改为此条件'))   # 清除所有条件字符唯一条件


x = 'a c d e'
print(x.replace(' ','',1))     # ac d e
print(x.replace(' ',''))       # acde


案例：
inp_user = input("username>>>: ").strip()  # inp_user = "      egon" = egon
inp_pwd = input("password>>>: ").strip()
if inp_user == "egon" and inp_pwd == '123':
	print('ok')
else:
    print('no')


(6)、切分split：把一个字符串按照某种分割符切分一个列表
msg = "egon:18:male:10"
res = msg.split(':')      # 以字符 ":"为标准切分
print(res)
print(res[0])

res = msg.split('切分的条件',切分的次数)
print(res)


6.1 把列表中的元素按照某种分隔符拼接成字符串
info = ['egon', '18', 'male', '10']
msg = ":".join(info)     #"egon:18:male:10"
print(msg)

(7)、循环
msg = "hello world"
for i in msg:
	print(i,end(""))     # 每个字母依次输出，但是不换行


需要掌握的操作（****）
1、strip,lstrip,rstrip
print("******egon*****".strip('*'))    # 清除两边的条件字符
print("******egon*****".lstrip('*'))   # 只清除左边的条件字符
print("******egon*****".rstrip('*'))   # 只清除右边的条件字符

2、lower,upper
print("AbC".lower())    # 字母全小写
print("AbC".upper())    # 字母全大写

3、startswith,endswith
print('hello world'.startswith('he'))   # 检查字符开头是不是条件字符
print('hello world'.endswith('d'))      # 检查字符结尾处是不是条件字符
print('hello world'.startswith('e',1,4))  # 检查字符开头1~4个字符是否符合条件


4、format的三种玩法
print("my name is %s my age is %s" % ('egon', 18))
print("my name is {name} my age is {age}".format(age=18,name='egon'))
print("my name is {} my age is {}".format(18,'egon'))
print("my name is {1} my age is {0}{0}{0}".format(18,'egon'))  # 直接按照序列引用
x = 'egon'
y = 18
print(f'my name is {x} ,my age is {y}')   # format的快捷引用只在python3中适用

5、split,rsplit
msg = 'egon:18:male'
print(msg.split(':',1))    # 从左向右划分字符串
print(msg.rsplit(':',1))   # 从右向左划分字符串


# 6、join              字符拼接成字符串
# 7、replace           清除字符串内条件字符
# 8、isdigit           检查字符串是不是由全数字组成
# print("18".isdigit())  

age = input('>>>: ').replace(' ', '')    # 猜数字的小游戏
if age.isdigit():                        # 输入第一次猜数
    age = int(age)                       # 将输入的值转换成整型
    if age > 18:                         # 如果 输入数 大于18
        print('too big')                 # 输出
    elif age < 18:                       # 如果 输入数 小于18
        print('too small')               # 输出
    else:                                # 否则
        print('you got it')              # 输出
else:                                    # 否则
    print("必须输入数字，小垃圾")          # 输出

# 需要的了解的操作（***）
#1、find,rfind,index,rindex,count
msg = 'hello egon ahahah egon xxx egon'
print(msg.find('egon1'))       # 字符串检索在检索目标中输出存在次数 否则输出-1
print(msg.index('egon1'))      # 字符串检索在检索目标中输出存在次数 否则报错
print(msg.rfind('egon'))       # 从右边开始索引


#2、center,ljust,rjust,zfill     输出字符串并在两边添加新字符使总长达到目标长度
print('egon'.center(50,'*'))   # 两边 50 *
print('egon'.ljust(50,'*'))    # 左边 50 *
print('egon'.rjust(50,'*'))    # 右边 50 *
print('egon'.zfill(50))        # 左边 50 默认0


#4、captalize,swapcase,title
print('abcd'.capitalize())         # 字符串全小写
print('AbCd'.swapcase())           # 字符串全大写
print('my name is egon'.title())   # 字符串首字母大写

#5、is数字系列   
# print('18'.isdigit())           # 检查字符串是否为纯数字
# print('Ⅳ'.isnumeric())

#6、is其他
name='egon'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
# print(name.islower())
# print(name.isupper())

# name=' '
# print(name.isspace())

# name = 'My Is Egon'
# print(name.istitle())


# ======================================该类型总结====================================
# 存一个值

# 有序

# 不可变

列表的基本使用

===================================list基本使用======================================
1、用途

2、定义方式：在[]用逗号分隔开多个任意类型的元素
# l = [111,33.333,"aaaa",[666,7777]]  # l = list(...)
print(type(l))

# list数据类型转换
res = list("hello")
print(res)     "h" "e" "l" "l" "o"

3、常用操作+内置的方法
3.1 优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可存也可以取
l = [111,222,333,444,555,666,777]
print(l[0])
print(l[-1])
print(id(l))
l[0] = 999
print(id(l))

# l[7] = 888  # 如果索引不存在则报错

2、切片(顾头不顾尾，步长)
l = [111,222,333,444,555,666,777]
print(l[1:4:1])  # 拷贝

print(l[:])
print(l[::-1])

3、长度
l = [111,222,333,444,555,666,777]
print(len(l))

4、成员运算in和not in
l = [111,222,333,444,555,666,777]
print(333 in l)

5、追加、插入
l = [111,222,333,444,555,666,777]   # 向字符串末尾加入字符
l.append(888)    

l.insert(3,999999999999)           # 在3索引后插入字符
print(l)


6、删除
l = [111, 222, 333, 444, 555, 666, 777]
（1）万能删除
del l[1]                # 索引删除没有返回值
print(l)

(2) l.remove()
v = l.remove(333)       # 定点删除没有返回值
print(l)
print(v)

(3) l.pop()
v = l.pop(2)            # 索引输出 返回删除值
print(l)
print(v)

7、循环
l = [111,222,333,444,555,666,777]
for i in l:
    print(i)


3.2 需要掌握
l = [111,222,333,444,333,555,666,777]
print(l.index(333))          
print(l.index(9999))        # 字符串检索在检索目标中输出存在次数 否则报错
print(l.count(333))         # 字符串检索在检索目标中输出存在次数

l = [111,'a',333,'dddd']
l.reverse()                 # 反转输出
print(l)

l = [111,'a',333,'dddd']
l = [111, -3, 99, 27]      # 从小到大排序   
l.sort(reverse=True)       # 反转输出
print(l) 

l = [111, -3, 99, 27]
nums = [333,444,555]
l.append(nums)            # 将nums列表的内存地址添加到l字符串中
l.extend(nums)            # 直接将列表里面的内存地址追加
print(l)



print(len(l))  # l.__len__()     计数

new_l = l.copy()         # 拷贝
new_l = l[:]             # 切片


# ======================================该类型总结====================================
# 存多个值

# 有序

# 可变

元组的基本使用

==================================元组基本使用======================================
1、用途：元组就是一种不可变的列表

2、定义方式：在()内用逗号分割开多个任意类型的元素
t = (11,11.333,"aaa",[666,777])  # t = tuple()
print(type(t))
t[0] = 999
t = (1111,)
print(type(t))

# tuple数据类型转换
# print(tuple("hello"))

3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
2、切片(顾头不顾尾，步长)
3、长度
4、成员运算in和not in

需要了解的
t = (111,222,222,222,333)
print(t.count(222))
print(t.index(222))

# ======================================该类型总结====================================
# 存多个值

# 有序

# 不可变
t = (11, 22, [33, 44])
t[2][0] = 66