0基础python笔记

基础数据类型 
一：字符串str      字符串用单引号(‘ ’)或双引号(“ ”)括起来，同时使用反斜杠(\)转义特殊字符

a = '你好'
print(type(a))      #<class 'str'>

二： 整型 int         通常被称为是整型或整数，是正或负整数，不带小数点

b = 11
print(type(b))    #<class 'int'>

三：浮点型float     浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示

c = 12.56
print(type(c))      #<class 'float'>

四：bool 布尔型      是用来表示真(对)或假(错)

d = True
print(type(d))      #<class 'bool'>

五：list 列表          列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，

e = [10,111,12]
print(type(e))      #<class 'list'>

六：tuple 元组       元组使用小括号 ( ) 只需要在括号中添加元素，并使用逗号隔开

f = (52 ,56,89)
print(type(f))       #<class 'tuple'>

七：set 集合         可以使用大括号 { } 或者 set() 创建空集合必须是使用set

g = {59,852,889}
print(type(g))       #<class 'set'>

八：dict 字典        它的元素以“键值对（key-value）”的形式存储

h = {"age":18,"name":"小米"}
print(type(h))     #<class 'dict'>

数据类型的操作
一：字符串str的基础操作  str容器

1.支持获取元素下标[ ] 

new_str = '张三 李四 王武'
ss = new_str[0]
print(ss)            #  张

2.找到字符串下标的位置 index

new_str = '张三 李四 王武'
d = new_str.index('张')
print(d)           #0

3.修改字符串 替换字符串 replace

new_str = '张三 李四 王武'
d = new_str.replace('王武','zhaoliu')
print(d)  
 print(new_str)          #张三 李四 zhaoliu

4.切分字符串 split(分割字符，分割次数)   切分后会得到一个list[ ] 并且会用逗号隔开

string = ' www.gziscas.com.cn '
# 不传入参数默认去除字符串前后的空格
print(string.split(' '))           #['www.gziscas.com.cn']
# 传入参数 从逗号开始分隔两次
print(string.split('.',2))         #['www', 'gziscas', 'com. cn']
#切分两次取序列为1的元素
print(string.split('.',2)[1])      #gziscas
#分割两次并把分割后的数据保存在文件里
use1,use2,use3 ,use4= string.split('.',3)
print(use1)       #www
print(use2)       #gziscas
print(use3)       #com
print(use4)       #cn
#替换空格为 |
str3 = "hello boy byebye"
string1 = str3.replace(' ','|')
print(string1)     #hello|boy|byebye

5. 统计字符串长度 len（）

init_str = 'abcdefgff'
print(len(init_str))   #9

6. 统计某字符在字符串中出现的次数 count()

init_str = 'abcdefgabcagff'
print(init_str.count('a'))         #3

7. 删除开头和结尾的空白字符 

# 删除开头和结尾的空白字符
init_str1 = '  ab,de,ga,ca,na,ff   '
print(f'删除前：{init_str1}')                   # ab,de,ga,ca,na,ff 
print(f"删除后: {init_str1.strip()}")         #ab,de,ga,ca,na,ff
# 删除开头（左）空白字符
print(f"删除后: {init_str1.lstrip()}")          #ab,de,ga,ca,na,ff
# 删除结尾（右）空白字符
print(f'删除前：{init_str1}')                   # ab,de,ga,ca,na,ff 
print(f"删除后: {init_str1.rstrip()}")        #ab,de,ga,ca,na,ff
# 删除开头结尾指定字符
init_str2= '#abc#deffhueosft###' 
print(f'删除前：{init_str2}')                        #abc#deffhueosft###
print(f"删除后: {init_str2.strip('#')}")          #abc#deffhueosft
# 删除开头（左）空白指定字符
print(f'删除前：{init_str2}')                       #abc#deffhueosft###
print(f"删除后: {init_str2.lstrip('#')}")         abc#deffhueosft###

8. 将大写的字母转成小写的字母lower()

str1 = 'ABC'
print(str1.lower())                  #abc

9.将小写的字母转成大写的字母 upper()

str1 = 'def'
print(str1.upper())                 #DEF

10.用in判断字符是否在字符串中 有就是Ture   没有就是False

str1 = 'ghigk' print({'gh' in str1})   #{True}
print({'ab' in str1})                  # {False}

11.字符串做加、乘运算

init_str = 'abc'
print(f'相加前: {init_str}')                 #abc
print(f"相加后: {init_str+ 'cdf'}")      #abccdf
print(f"相乘后: {init_str* 5}")          #abcabcabcabcabc
二：int整型的基础操作

二：list 列表  的基础操作 list容器  可以使用while循环 和 for循环

1.列表内存储的数据 可以是任意类型

new_lis = ['张三','李四','王武',123,True,0.9]
print(type(new_lis)) #<class 'list'>
print(new_lis) #['张三', '李四', '王武', 123, True, 0.9]

2.列表嵌套

new_list1 = [[1,3,4],['张三','李四']]
print(new_list1) #[[1, 3, 4], ['张三', '李四']]

3. 列表的下标索引-（通过下标索引可以取出列表中的元素）-----使用列表的下标索引从列表中取出元素  表的下标索引 从0开始 从右向左逐步+1-----

# 列表的下标索引-（通过下标索引可以取出列表中的元素）-----使用列表的下标索引从列表中取出元素
# 列表的下标索引 从0开始 从右向左逐步+1-----
my_list = ["Tom","liyl","rose"]
print(my_list[0]) #Tom
print(my_list[1]) #liyl
print(my_list[2]) #rose

# 超出范围报错
print(my_list[3])  #IndexError: list index out of range

# 从左向右 列表的第一个元素标记为-1 依次递减
my_list = ["Tom","liyl","rose"]
print(my_list[-1])
print(my_list[-2])

4. 取嵌套列表的元素

y_list =[["Tom","liyl","rose"],[1,2,3,4,5]]
print(my_list[0][1]) #liyl
print(my_list[1][-1]) #5
print(my_list[0][2]) #rose

5.列表的查询 查询元素在列表的下标 index（）

index_list = [1,2,3]
print(index_list.index(1)) #0

6. 修改特定下标的索引值 修改后等于获得新的列表

index_list = [1,2,3]
index_list[2] = '张三'
print(index_list)  #[1,2,'张三']

7.在列表指定的元素位置插入新元素insert（）

index_list = [1,2,3]
index_list.insert(1,'number')
print(index_list)  #[1, 'number', 2, 3]

8.在列表的尾部 追加新元素 只能添加单个元素 append（）

index_list = [1,2,3]
index_list.append('zhangsan') #[1,2,3，'zhangsan']

9.在列表的尾部 追加多个元素extend（）

index_list = [1,2,3]
ex_list = ['张三','李四','王武']
index_list.extend(ex_list)
print(index_list) #[[1, 3, 4], ['张三', '李四']]

10.删除列表的元素 通过列表下标 del

index_list = [1,2,3]
del index_list[1]
print(index_list)     # 结果[1, 3]

11.删除列表的元素 通过列表下标元素 pop----还可以将删除的元素用变量接受 等于能接受到opo的返回值

index_list = [1,2,3]
element = index_list.pop(0)
print(index_list)     # 结果[2, 3]
print(element)        # 结果是1

12. 删除某个元素在列表中的匹配项 remove

index_list = [1,2,3]
index_list.remove(3)
print(index_list)     # 结果是[1, 2]

13. 清空列表元素内容

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

14.统计列表内某个元素的数量 count

index_list = [1,2,3,2,2]
con = index_list.count(2)
print(con)   # 3

15. 统计列表内所有元素的数量 len（）

index_list = [1,2,3,2,2]
print(len(index_list))  #5

三：元组的操作tuple 元组的元素可以是任意类型的数据类型 ---单个元组后面需要添加逗号， 不添加逗号的数据类型是字符串 ---元组的特点-----不可修改   元组支持while循环和for循环

一：元组的元素可以是任意类型的数据类型tuple（）

new_t1 = ('张三', 1, True)
# 单个元组需要在后面添加逗号  不加逗号的数据类型是字符串
new_t2 = ('zhangs',)

2. 元组可以嵌套  取出元组通过下标索引取出元素内容

# 元组可以嵌套
t3 = ((1, 2, 3, 4), ('hello', True, 90))
# 取出元组通过下标索引取出元素内容
a = t3[1][-1]  # 90
print(a)
# 元组的特点-----不可修改

3. 查询元组元素指定元素的下标 index（）

# 查询元组元素指定元素的下标 index
t4 = (1, 2, 3, 4)
t5 = t4.index(1)
print(t5)  #2

4.统计元组指定元素出现的数量 conut（）

# 统计元组指定元素出现的数量 conut
tr = (1, 2, 3, 4)
t6 = tr.count(1)
print(t6) #1

5. 统计元组的元素长度

tr = (1, 2, 3, 4)
tt = len(tr)
print(tt) 

四：切片是str list tuple的一种高级索引法 普通索引只取出序列中 一个下标 对应的元素，而切片取出序列中 一个范围 对应的元素

1.切片语法：[开始：结束：步长] 正索引和负索引   
#单独一个冒号,代表从头取到尾,步长默认为1

b=[6,3,6,7,8,2,5,4]
a= b[:] ##单独一个冒号,代表从头取到尾,步长默认为1
print(a)   #

#从0开始 到4结束 不包含4本身步长为2

b = [6, 3, 6, 7, 8, 2, 5, 4]
a = b[0:4:2]# 从0开始 到4结束 不包含4本身步长为2
print(a) #[6, 6]
b = [6, 3, 6, 7, 8, 2, 5, 4]
a= b[::-1]##注意,两个冒号后面是步长,步长为1,故应从右往左取
print(a)

五：集合  集合是无序的 不支持下标索引 不能用while循环  集合自带去重
1.集合添加新元素 add（）

ste1 = {1,1,2,2,3,45}
ste1.add('zhangs')
print(ste1)   #{1, 2, 3, 45, 'zhangs'}

2.移出集合元素 remove（）

ste1 = {1,1,2,2,3,45}
ste1.remove('zhangs')
print(ste1)  #{1, 2, 3, 45}

3. 随机取出集合元素pop（）

ste1 = {1,1,2,2,3,45}
ss = ste1.pop()
print(ss)  #1

4. 清除集合元素clear（）

ste1 = {1,1,2,2,3,45}
ste1.clear()
print(ste1) #set()

5. 取出集合的差集 difference（）个集合内有的元素 一个集合内没有的元素 取出后得到一个新集合 原集合的元素不变

my_set1 = {1,2,3}
my_set2 = {1,2,3,4,5}
my_set3 = my_set2.difference(my_set1)
print(my_set3 ) #{4, 5}

6. 消除差集 difference_update （）在一个集合内消除和另一个集合相同的元素 集合1 会发生变化 集合2不会发生变化

my_set11 = {1,2,34,5}
my_set22 = {1,2,3,4,5}
my_set11.difference_update(my_set22)
print(my_set11)   #{34}
print(my_set22)   #{1, 2, 3, 4, 5}

7. 集合并集合 union

my_set11 = {1,2,34,5}
my_set22 = {1,2,3,4,5}
my_set33 = my_set11.union(my_set22)
print(my_set33) #{1, 2, 34, 3, 5, 4}

六：字典dict 字典不支持下标索引   字典可以嵌套  但是字典的key和value可以是任意数据类型 但key不能是字典
字典的每个健值的展现方式是：key:value用冒号分割；键值之间为逗号分割；整个字典用大括号｛｝将键值括起来；字典是无序的，它不能通过偏移来存取，只能通过键来存取；键必须是唯一；键必须是不可变的数据类型，比如，数字，字符串，元组等，列表等可变对象不能作为键；键值可以是任意类型的对象；

1. 字典的定义 

# 定义空字典 两种方式
dict = dict()
dict1 = {}
print(type(dict))  #<class 'dict'>
print(type(dict1)) #<class 'dict'>

1.1定义有值的字典

my_dict = {'张三':'10','李四':'11','王五':'5',}
print(type(my_dict))  #<class 'dict'>
print(my_dict) #{'张三': '10', '李四': '11', '王五': '5'}

1.2定义重复key的字典   后面的覆盖了前面的 因为字典不允许key重复

my1_dict = {'张三':'10','李四':'11','王五':'5','张三':'101',}
print(my1_dict)  #{'张三': '101', '李四': '11', '王五': '5'} #后面的覆盖了前面的 因为字典不允许key重复

# 字典不能使用下标 但是字典可以通过key值来取的对应的value
my2_dict = {'李四':'11','王五':'5','张三':'101',}
print(my2_dict['李四'])   #11

3.字典的嵌套  字典的key和value可以是任意数据类型 但key不能是字典

# 字典的key和value可以是任意数据类型 但key不能是字典
dict_nest= {
    "张三":{
        "年龄":77,
        "专业":'计算机',
        "体重": 120
    },
    "李四":{
        "年龄":66,
        "专业":'生物研究',
        "体重": 100
    },
    "王五":{
        "年龄":25,
        "专业":'科学研究',
        "体重": 150
    }
}
print(dict_nest)

3.1 从嵌套字典获取数据

scors = dict_nest['张三']['年龄']
print(scors) 

4.添加字典元素 

my_dict1 = {'张三':'10','李四':'11','王五':'5',}
# 字典新增元素  添加后其实是获得了一个新的字典
my_dict1['张三'] = 11
print(my_dict1)   #{'张三': 11, '李四': '11', '王五': '5'}

5. 更新字典的元素 如果字典key不存在 等于是更新了新的字典

my_dict1 = {'张三':'10','李四':'11','王五':'5',}
# 更新元素   如果key不存在 等于更新新的字典
my_dict1['赵六']= 12
print(my_dict1)  #{'张三': '10', '李四': '11', '王五': '5', '赵六': 12}

6. 删除字典 Clear( )等于是清空了字典的元素

删除字典
my_dict1 = {'张三':'10','李四':'11','王五':'5',}
my_dict1.clear()
print(my_dict1) #{} 清空了字典

7.取出字典对应的value 并在字典内容删除此key的键值对 pop()

# 取出字典对应的value 并在字典内容删除此key的键值对 pop
my_dict1 = {'张三':'10','李四':'11','王五':'5',}
dict_pop=my_dict1.pop('张三')
print(dict_pop)  #10

8. 获取全部字典key  keys()

my_dict1 = {'张三':'10','李四':'11','王五':'5',}
keys = my_dict1.keys()
print(keys)   #dict_keys(['张三', '李四', '王五'])

9.字典遍历

# 遍历字典
# 方式1
for key in keys:
    print(key)  #张三  李四  王五
print('====================================================方式1')
# 方式二：
for key in my_dict1:
    print(my_dict1[key])  #张三  李四  王五
print('====================================================方式二')
# 统计字典内的元素数量
my_dict1 = {'张三':'10','李四':'11','王五':'5',}
len = len(my_dict1)
print(len)  #3
print('====================================================')

10.根据key来获取字典的value   get()当访问的value吧存在key时 就会报错

dict = {'语文': 10, '数学': 40, '英语': 20}
print(dict .get('化学'))    #  None
print(dict['历史'])      # 报错 KeyError: '历史'

11.更新已有的字典  update() 如果被更新的字典中己包含对应的 key-value 对，原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去

dict = {'语文': 96, '数学': 45, '英语': 110}
dict.update({'语文': 130, '数学': 1152})
print(dict)      # 输出{'语文': 130, '数学': 1152, '英语': 110}

12. 返回可遍历的字典内存储的元素items()

dict = {'语文': 105, '数学': 140, '英语': 120}
print(dict.items())  # 输出 items([('语文', 105), ('数学', 140), ('英语', 120)])

13.弹出字典的最后一个元素popitem()

dict = {'语文': 105, '数学': 140, '英语': 120}
print(dict.popitem())  # 输出('英语', 120)

 七:运算复基础
1.:算数运算符

# 加 +   减 -  乘 *  除/  整除//  取余 %  **指数  （）小括号
print(1+1)
print(5 - 3)
print(7 * 7)
print(7 / 3)
print(10 // 3)
print(4 % 3)
print(6 ** 2)
print((1+2)*3)
print((7*7)+ 8 ** 2)

2.赋值运算符 单个变量赋值   多个变量赋值 多个变量赋相同的值

# =  单个变量赋值
a = 1
print(a)
# 多变量赋值
b = c =4
print(b)
print(c)

# 多个变量赋相同的值
d,e,f = 1,2,3
print(d)
print(e)
print(f)

3.复合赋值运算符

# += -= *= /= //= (整除) %=  **=
a = 2
a+=2
print(a)

a = 2
a-=2
print(a)

# 复合赋值运算符和表达式 先算表达式  在把表达式的结果带到复合赋值运算符内计算
a = 3
a += 3 + 3
# 先算3+3
print(a)

a = 4
a -= 2-1
print(a)

4.比较运算符

# == !=  < >   <=  >=
print(1 ==1)
print(1 != 1)
print(1 < 1)
print(3> 1)
print(1<= 1)
print(3>= 3)

5.数字之间的运算符and  和 or 

# and  和 or 带着数字0 参与运算
# and只要有一个值为0  结果都为0  不为0 的时候返回的是最后一个数字

a = 0
b = 1
c = 2
print(a and b)
print(b and a)
print(b and c)


# 所有值为0 结果才为0  返回的是第一个数字
print(a or  a)
print(a or b)
print(c or a)

6.逻辑运算符and  都真才真  #  or 都假才假  # not 取反

#  and  or not
# and  都真才真
#  or 都假才假
# not 取反

a = 1
b = 2
c = 3
print(a >= b and a <= 3)
print(a <= b and a <= 3)

print(a <= 2 or a >= 3)
print(c >= b or b <= c)
print(a >= b or a >= c)

print(not a<=b)

7. 三目运算符
 

a = 1
b = 2
c = a if a > b else b
print(c)
c = 2
print('c是偶数') if c % 2 == 0 else print('c是奇数')

a = 20
b = 30
c = 40
num = a if a > b else c if a + b > c else a + b
print(num)

8.转义字符

# 1.转义字符 会换行展示\n     制表符号 一个tab的距离 \t    结束符号end
# 一行输出
print('holle word')
# 两行输出
print('hell\nword')
# 指标符号
print('\thellword')
#  结束符号
print('hello weord',end='\n')

八:数据类型转换基础 str int float list tuple eval

1.字符串类型转化为数值类型 为什么要转化数据类型 因为 input 接受到的数据类型是字符串

numb = '4'
print(type(numb))
# 此时numb的数据类型是str
# int函数转化数据类型为整型
print(type(int(numb)))

2.将整数类型转化为浮点型

# float
# 将整数类型转化为浮点型
int1 = 1
print(type(int1))
print(type(float(int1)))
print(float(int1))

3.将字符串转换为浮点型

str1 = '2'
print(type(str1))
print(type(float(str1)))
print(float(str1))

4.将整形转化为字符串

int2 = 34
print(type(int2))
print(type(str(int2)))
print(str(int2))

5. 将浮点型数据转化为字符串

nubb = 45.78
print(type(nubb))
print(str(nubb))
print(type(str(nubb)))

6. 将列表转化为元组

list1 = [10,20,30]
print(type(list1))
print(type(tuple(list1)))
print(tuple(list1))

7.  元组转化为列表

tuple1 = (23,45,4,5)
print(type(tuple1))
print(type(list(tuple1)))
print(list(tuple1))

8. eval  将字符串中的数据 转化为数据原本的类型

str1_1 = '2'
print(type(eval(str1_1)))
print(eval(str1_1))

9.  字符串内存放浮点型

falot_1 ='0.89'
print(type(eval(falot_1)))
print(eval(falot_1))
# 字符串内存放列表
li = '23,34,56'
print(eval(li))

九:循环基础
1. while循环

# i = 0
# while i <= 4:
#     print('不听话拉出去宰了')
#     i += 1

# a = 1
# while a <= 3:
#     print('11')
#     a += 1

# 从0开始
# i = 0
# 带入0计算  只要小于 5 循环到4时候 判断4小于5 就打印5次 因为从0开始
# while i < 5:
#     print('1')
#     i+=1

# 计算0到100的累加和
# i = 1
# result = 0
# while i <= 100:
#     result += i
#     i+=1
# print(result)
#
# # 1到100偶数的累加和
# i = 1
# sum = 0
# while i<=100:
#     if i%2 != 0:
#         sum = sum + i
#     i+=1
#
# print("1~100的奇数累积和为:%d"%sum)
#
#
# a = 0
# b = 0
# while a <= 100:
#     if a % 2 == 0:
#         b +=a
#     a+=1
# print(b)
#
# # 计数器
# i = 2
# c = 0
# while i < 100:
#     c += i
#     i +=2
# print(c)
#
# i = 1
# num = 0
# while i <= 100:
#     if i % 2 != 0:
#         num +=i
#     i+=1
# print(num)

# 求和
i = 0
sum = 0
while i <= 100:
    sum +=i
    i+=1
print(sum)

# 偶数和
i = 0
num = 0
while i <= 100:
    if i % 2 == 0:
        num += i
    i+=1
print(num)
# 奇数
i = 0
sum = 0
while i <= 100:
    if i % 2 != 0:
        sum += i
    i +=1
print(sum)

2.双while循环   双while 外层控制自身循环 也控制内层循环

i = 1
while i <= 100:
    print(f'这是第{i}天准备表白')
    # 内层循环控制次数
    j = 1
    while j <= 10:
        print(f'hha {j}')
        j+=1

    i+=1
    print('我喜欢你')
print(f'坚持到{i -1} -天表白成功')

3.for循环

# 循环遍历出带a的 总共有几个
gess = 'itheima is a for school '
g = 0
for i in gess:
    if i == 'a':
        g+=1
print(f'zhe li miayou{g}')
print('=========================================')
# range===三种写法  ①打印一0到9的的一个序列  ②打印从5开始到10的序列 不包含10  ③打印5到10的序列不包含10 步数是2
# range(10)①打印一0到9的的一个序列
for i in range(10):
    print(i)
print('====================================')
# 从5开始到10结束 不包含10本身的序列  ②打印从5开始到10的序列 不包含10
for i in range(5,10):
    print(i)
print('=======================================')

# 从0开始 到10结束 不包含10 步数是2   ③打印5到10的序列不包含10 步数是2
for i in range(5,10,2):
    print(i)
print('=======================================')

num = 100
sum1 = 0
for i in range(1,num):
    if i %2 == 0:
        sum1+=1

print(f'偶数有{sum1}个')

10.双for循环

1. # 送100天花每天送10朵
   # for i in range(1,101):
   #     print(f'这是送花的第{i}天')
   #     for x in range(1,11):
   #         print(f'这是送的第{x}朵')
   # print('还是喜欢你')
   
   # 双for循环打印乘法表
   # for i in range(1,10):
   #     for j in range(1,i+1):
   #         print(f'{j} * {i} = {j*i}\t',end='')
   #         j+=1
   #     i+=1
   #     print('')