python基础（全）带图详解

数据类型

变量和数据类型

变量

print(type(变量名)) ——查看数据类型
1 定义变量时，不需要指定变量的类型，直接为变量赋值即可。
2 变量名要符合命名规范
数据类型：整型、浮点型、字符串、布尔、空值等

• 整型 int

num=123456789
print(num)
print(type(num))

• 浮点型 float

num=3.14
print(num)
print(type(num))

• 整型 str ——字符串可以使用单引号或双引号（推荐单引号）

a='abc'
b='def'
print(a,type(a))
print(b,type(b))

特殊使用，外面用单引号，里面可以用双引号，这样双引号就可以打印出来，
双单引号，如果不定义变量名就是注释，如果定义变量名，表示的就是字符串，而且格式也会被保留

print('你问我："生活是什么"')

plus='''
认真生活
    努力奋斗
        才有资格优雅老去

'''
print(plus,type(plus))

• 布尔-bool——True和False（首字母大写）

另外 True表示1，False表示0，

• 空值 NoneType
  

字符串

类型转换

数值类型不能直接和字符串进行拼接，需要进行类型转换str(字符串)

字符串常用方法

常用的查找方法

string = '''
慢慢才知道很多东西是可遇而不可求的，很多东西只能拥有一次；
慢慢才知道人的性格可以差异到如此之大；
慢慢才知道两个天天在一起的人不一定是朋友，有可能什么都不是；
慢慢才知道手机是别人有事找你时用的，并不是为交流感情的；
慢慢才知道快乐常常来自回忆，而痛苦常常来自于回忆与现实的差距。'''
# 注 如果 上述这种方法定义内容，'''结束和内容不在同一行，返回结果和理想的不一样。

print(len(string))#字符串长度
print(string.startswith('慢'))#以指定字符串开头，返回结果为布尔类型
print(string.endswith('差距。'))#以指定字符串结尾，返回结果为布尔类型
print(string.find('知道')) #第一次指定字符串出现的位置
print(string.rfind('知道'))#最后一次指定字符串出现的位置
print(string.count('知道'))#指定字符出现了几次
print(string.isalnum())#所有字符全是字母或数字，返回结果为布尔类型

去掉空格和特殊符号

name = '   hello ccx   '
print(name.strip())#去掉两端空格和换行符
print(name.lstrip())# 去掉左边的空格和换行符
print(name.rstrip())# 去掉右边的空格和换行符

name1 = '*hello*ccx*'
print(name1.strip('*'))#去掉两端指定字符串
print(name1.lstrip('*'))# 去掉左边指定字符串
print(name1.rstrip('*'))# 去掉右边指定字符串 

linux中可以直接这么测试：

>>> "*c*c*x*".strip("*")
'c*c*x'
>>> "*c*c*x*".lstrip("*")
'c*c*x*'
>>> "*c*c*x*".rstrip("*")
'*c*c*x'
>>> " ccx ".strip()
'ccx'

字母大小写转换

string = 'xgq love ccx, LOVE ONE CCX'
print(string.capitalize()) #产生新的字符串，首字母大写
print(string.title())# 产生新的字符串，每个单词都首字母大写
print(string.upper()) # 产生新的字符串，所有字符转换为大写
print(string.lower())# 产生新的字符串，所有字符全转成小写
print(string.swapcase()) # 所有字母大小写转换

自动补齐

print('ccx'.center(10,"*")) # 10个参数，不足的两边补齐*
print('ccx'.ljust(10,"*"))# 10个参数，不足的右边补齐*
print('ccx'.rjust(10,"*")) # 10个参数，不足的左边补齐*

检测（判断）——返回结果为 布尔类型

1. isalnum()是否为字母或数字
2. isalpha() 检测字符串是否只由字母组成(含汉字)。
3. isdigit() 检测字符串是否只由数字组成。
4. isspace() 检测是否为空白符
5. isupper() 是否为大写字母
6. islower() 是否为小写字母

print('ccx1997'.isalnum()) #是否为字母或数字
print('崔崇鑫1997！！！'.isalpha()) #检测字符串是否只由字母组成(含汉字)。
print('1234557'.isdigit()) #检测字符串是否只由数字组成。
print('  abc'.isspace()) #检测是否为空白符
print('CCx'.isupper())#是否为大写字母
print('ccx'.islower()) #是否为小写字母

切片：用来获取指定索引范围的内容

name = 'ccx is a hero'
print(name[0]) # 获取第一个字符
print(name[5]) # 获取第五个字符
print(name[len(name)-1],name[-1]) # 获取最后一个字符的两种方法
print(name[1:5]) # 获取第1(默认+1)到5个字符
print(name[:5]) # 默认从第一个开始获取到第5个字符
print(name[1:10:2]) # 从第二个开始到第10个字符，每隔2个取一个值
print(name[::2]) # 所有字符，每隔两个取一个值

字符串的格式化

• 方法一
  使用%占位符，%s表示任意字符，%d表示整数，%f表示浮点数

name = '崔崇鑫hero'
age = '22'
height = 170.51

# 注意，如果参数中没有 '',混合使用会报错，需要定义类型。
print('大家好，我叫'+name+',今年+'+age+'岁，身高'+str(height)+'cm')

#使用格式化的方法可缩写为
# %2.3s意思是只显示2-3个参数，%0.1f是保留一位数
print('大家好，我叫%2.3s，今年%s，身高%.1fcm'%(name,age,height))
# %02d意思是，不足2位，用0填充
print('当前时间：%d年-%02d月-%d日' % (2020,3,28))

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

位置固定顺序实现方法

name = '崔崇鑫hero'
age = '22'
height = '170.51'

print('大家好，我叫{0},今年{1}岁,身高{2}cm,摊牌了，我是高富帅，坐拥**资产！！！！'.format(name, age, height))

位置非固定实现方法

name = '崔崇鑫hero'
age = '22'
height = '170.51'

#print('大家好，我叫{0},今年{1}岁,身高{2}cm,摊牌了，我是高富帅，坐拥**资产！！！！'.format(name, age, height))
print('大家好，我叫{name},今年{age}岁,身高{height}cm,摊牌了，我是高富帅，坐拥**资产！！！！'.format(age=age,name=name, height=height))

• 方式3
  在字符串前面添加一个f，使用{变量名}来嵌入变量

name = '崔崇鑫hero'
age = '22'
height = '170.51'

#print('大家好，我叫{0},今年{1}岁,身高{2}cm,摊牌了，我是高富帅，坐拥**资产！！！！'.format(name, age, height))
#print('大家好，我叫{name},今年{age}岁,身高{height}cm,摊牌了，我是高富帅，坐拥**资产！！！！'.format(age=age,name=name, height=height))
print(f'大家好，我叫{name},今年{age}岁，身高{height}cm，摊牌了吧，我是高富帅，别问为什么！！！')

• 总结
  其实上面3个方式中，方式3最复杂，方式2 逼格最高，但方法1 是通用的，就是说 什么语言基本上都是这个流程，所以个人建议 别搞那些花里胡哨的，老老实实用的方式1，方式2和方式3 看得懂就行！！！！！

运算符

运算符介绍

算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、条件运算符、成员运算符、身份运算符

算术运算符 + ­ * / % // ** 不支持自增++和自减

主要用于两个对象算数计算(加减乘除等运算)

print(3 + 5)
print(30 *  '-­')  #  乘法可以用于字符串，这里表示30个-
print('*' * 80) # 同样表示80个*
print(5 % 3) # 取余
print(5 / 3) #  除法，有小数
print(5 // 3)  #  除法，取整
print(2 ** 3)  #  幂
print(pow(2, 3))
i = 5
i = i + 1
print(i)

比较运算符 > < >= <= == !=或<>

用于两个对象比较(判断是否相等、大于等运算)
返回结果是布尔类型

j = 5
print(j > 2)
print(10 > j  > 1)# 支持此写法
print('abc' > 'acd') # 可以用于字符串的比较，比较的是字符串的Unicode编码

赋值运算符 = += ­= *= /+ %= **=

用于对象的赋值，将运算符右边的值(或计算结果)赋给运算符左边。

a=10 
a+=5# 等价于a= a+5 
print(a)

逻辑运算符 and or not

用于逻辑运算(与或非等)。
并不是所有逻辑运算符都是 布尔类型 ，也可以返回数值。
and：为真返回后面的值，为假返回当前值
or：为真返回当前值，为假返回后面的值
not：真则假，假则真（返回布尔类型）

print(True and False)
print(5 > 2 or 4 < 1)
print(not 5 > 2)
x = 0 # 0 表示False，非0表示True
y = 8
print(x and y)# 如果ｘ为True，则返回y；否则返回x
print(x or y)  # 如果x为True，则返回x；否则返回y
print(not x) # 如果x为True，则返回False，否则返回True

条件运算符，也称三目运算符

语法：条件为真时的结果 if， 条件 else 条件为假时的结果

print('aaa' if 5 < 2 else 'bbb')
print('aaa' if 5 > 2 else 'bbb')

位运算符 与& 或| 非~ 异或^ 左移<< 右移>>

对Python对象进行按照存储的bit操作。
通过二进制计算 的。

a = 5 # 00000101
b = 8  # 00001000
print(a & b) # 两位都是1才为1，否则为0
print(a | b) # 只要有一位为1，则为1，否则为0 
print(~a)# 如果为1，则为0，如果为0，则为1 
print(a^b)# 如果两位相同，则为0，不同为1
print(b>>2)# 二进制的所有位都向右移2位

成员运算符 in not in

判断一个对象是否包含另一个对象。 返回布尔类型

c = [3, 5, 12, 15, 7, 2]
d = 4
print(d in c)
print(d not in c)

身份运算符 is is not

判断是不是引用自一个对象。 返回布尔类型

m = [1, 3, 5, 7]
n = [1, 3, 5, 7]
x = n
print(m is n)
print(m is not n)
print(x is n)
'''    
is 和 == 的区别    
is 判断两个变量是否引用同一个对象    
== 判断两个变量的值是否相等 '''
print(m == n)

列表和元组

列表list是一种有序的集合，用来存储多个值，可以向列表中添加或删除元素
元组tuple与list很类似，也是用来存储多个值，但tuple中的元素只能在定义时初始化，初始化后就无法再修改
总结：列表list和元组tuple都是Python内置的一种集合，一个可变的，一个是不可变的

­­­列表list

#也就是所谓的增删改查

定义列表，使用[]

names  = ['tom',  'jack', 'alice', 'mike'] # 下面所有列表list都用的这个names
print(names)
print(type(names))

获取/设置元素

print(names[1], names[:3])
names[0] = 'lucy'
print(names)

追加元素

names.append('zhangsan')

在指定位置插入元素

names.insert(1, 'lisi')

删除元素

names.remove('jack')

弹出元素

print(names.pop(0)) # 如果不指定位置，默认弹出最后一个

获取元素个数

print(len(names))

可以存储不同类型的数据

names.append(25)# 不建议
names.append(True)
print(names)
print('­' * 80)

­­­­­­元组tuple

定义元组，使用()

nums = (3, 8, 13, 25, 38, 250)
print(nums)
print(type(nums))
print(nums[2], nums[-1])
print(nums[1:3])

解构赋值

# 太麻烦  不建议用
# a = nums[0]
# b = nums[1]
# c = nums[2]
# d = nums[3]
# e = nums[4]
# f = nums[5]

#可以使用这种方法赋值
a, b, c, d, e, f = nums
print(a, b, c, d, e, f)

条件判断 （if）

根据条件进行判断，从而执行不同的操作
使用 if…elif…else 语句

 #语法一：
 if (条件) : { 
 成立执行的代码块
 }
 elif （条件）：｛
 成立执行的代码块
 ｝
 ...
 else (条件):{
 成立执行的代码块
 }
 
 #语法二：
 if 条件  : 
 执行的代码块
 注：如果行距不一样，则代表当前if条件结束
 elif 条件:{
 执行代码块
 }
 elif 条件：｛
 执行代码块
 ｝
 
#demo：接受客户端输入的成绩判断
score = input()
if score >= str(90):
 print('优秀')
elif score >= str(70):
 print('良好')
elif score >= str(60):
 print('及格')
else:
 print('?????')
 

条件 可以为数字，可以为字符串
简写的条件，当判断条件为：零、空字符、None、空list等，表示False，否则为True

循环 while

重复性的执行某个操作，称为循环
两种：while ，for…in循环

• while
  语法：while 条件 ：

#计算1-100的和
i = 1
sum = 0
while i <= 100 :
    sum += i
    i += 1
print(sum)

• for…in
  主要就是区定义的一个区间中的值
  语法：先定义一个区间(集合)设置参数，for 新变量名 in 区间变量名 :

names = ['ccx','xgq','zl','zfy']
for name in names:
    print(name,end=',')

• range()介绍
  这是python内置函数，就是打印的意思，可以替代手动设置区间，效果如下：
  方法一:

for i in range(1,50,2):  # 生成一个[1,100]的整数序列，步长为2
   print(i,end=',')
print()

方法二：

range(0,5) # 定义取值范围
for j in range(3) : # 取3个值的意思
   print(j)

for k in range(6) : # 如果超出范围 则取定义区间的全部
    print(k,end='-')

方法三：

print(list(range(5))) # 按顺序打印列表
print(list(range(1,20,2))) # 1-20，每隔2个打印一次

demo：利用range()计算1-100的和

sum = 0
for i in range(1,101) :
   sum += i
print(sum)

demo：使用循环输出list中的每个元素的索引和元素

#使用循环输出list中的每个元素的索引和元素
#方法1
print('方法1：')
j = 0
naums = [1, 4, 12, 41, 55, 231, 7, 66]
for i in naums:
   j += 1
   print(str(j) + ':' + str(i))
print('_____________________________')

#方法2
print('方法2：')
for j in range(len(naums)):
   print(str(j),':'+str(naums[j]))

demo：输出list中除第一个元素意外的其他元素
naums = [1, 4, 12, 41, 55, 231, 7, 66]
#方法一
print('方法1:',end='')
print(naums[1:]) # 从第二参数开始，打印全部
#方法二
print('方法2:',end='')
for n in naums[1:] :
   print(n,end=' ')

break和continue

break

满足条件 结束该语句（循环）

for i in range(1,50) : # 输出1-50
    if i>20 : # 大于20 结束该循环
        break
    print(i,end='-')

continue

满足条件，跳过当前循环，开始下一次循环

j = 0
naums = [1, 4, 22, 12, 10, 41, 55, 231, 7, 66]
for i in naums:
    j += 1
    if i%2==0 :  # 只输出奇数（跳过偶数）
     continue
    print(str(j) + ':' + str(i))

字典和集合

dict全称dictionary，使用键­值（key­value）存储数据，在其他语言中一般称为map

定义dict

使用大括号{}，与js中的json很类似

#­­字典 
#定义dict，使用大括号`{}`，与js中的json很类似
scores  =  {'tom':  98,  'jack':  100,  'alice':  60}
print(scores)
print(type(scores))

获取

print(scores['jack']) # 方法一
print(scores.get('alice')) # 方法二

添加/设置(修改)

scores['lucy']  =  89
scores['tom']  =  100
print(scores)

弹出（删除）

print(scores.pop('tom'))
print(scores)

判断是否存在指定的key

print('alice' in scores) # 返回布尔类型
print(scores)

遍历

• 通过自带函数

print(scores.keys()) # 获取键
print(scores.values()) # 获取值
print(scores.items()) # 获取键值

• 通过循环遍历

scores  =  {'tom':  98,  'jack':  100,  'alice':  60}
for k in scores.keys():
    print(k, scores[k])  # 获取键值 方法一
print('­' * 80)

for v in scores.values():
    print(v)  # 获取值
print('­' * 80)

for k, v in scores.items():  # 相当于解构赋值 ： k,v = items 
    print(k, v)  ## 获取键值方法二
print('­' * 80)

集合

set是无序的，不允许重复
定义set，使用大括号{}
如果set中有重复的，只会显示一个

s = {3,5,5,6,12,31,66,77}
print(s)
print(type(s))

根据此特性，如果我们要过滤掉list中重复的值，可以直接转为set！

lst = [1,3,3,3,5,7,7,44,33,33] # list列表
num = set(lst) #转为set
print(num) # 过滤重复。。。
print(type(lst)) # list
print(type(num)) # set

#而且转换类型后的，可以继续以set方式操作！

# 添加
num.add(666)
num.add(1) #添加列表中有的，并不会显示
print(num)

# 删除
num.remove(44)
print(num)

# 遍历
for i in num:
 print(i,end='--')

添加

num.add(666)  # num是变量名
num.add(1) #添加列表中有的，并不会显示
print(num)

删除

num.remove(44)# num是变量名
print(num)

遍历

for i in num:   # num是变量名
 print(i,end='--')