python基础---（变量、数据类型、在pycharm中查看源码）

***如何在pycharm中查看源码：

　　

 

　　　　　　选中方法，Ctrl 加鼠标左键，即可打开方法的源码。

一、变量

1. 定义：把程序运行的中间结果临时的存在内存里，以便后续的代码调用。
2. 定义变量的原则：
   1. 只能由数字、字母、下划线组成，数字不能开头（不能有特殊字符）；
   2. 不能是python环境内的关键字
   3. 变量的定义要具有可描述性。
   4. 变量不能是中文。
   5. 不可太长

　　3.Python中查看关键字的方法:1.import keyword　　2.keyword.kwlist（获取所有关键字）

　　　　使用keyword模块查看python关键字；使用keyword.iskeyword()，来查看某一个是否

位关键字 

常量 

《：在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量

AGE_OF_OLDBOY = 56》

        定义方式：下划线(age_of_oldboy = 56)；和驼峰法(AgeOfOldboy = 56)

二、数据类型转换

　　1.　　int和bool数据类型转换：

　　　　int---->bool　　非0即True

　　　　bool---->int　　True是1；Flase是0

　　2.　　int和str类型转换：

　　　　所有的int都能转换成str    123；’123’　　123=str('123')

　　　　只有纯数字组成的str，才能转化成int       s=’123’   int(s)

　　3.　　str和bool类型的转换：　　#空list ,tuple ,dict的bool值都是False

　　　　str---->bool　　s = bool('')空字符串是False  ;  s = bool('qwe')是Ture。

　　　　bool---->str　　i = str(True/False)  print(i,type(i)) ;　　都是字符串。

　　4.　　字符串的split方法，可以将str----->list

　　　　　join（适用于str、列表、字典等可迭代对象）方法，可以将list等---->str

　　　　　用字符串做一个连接符，链接可迭代对象中的每一个元素（每一个元素都必须是str：li = [1,'qwe']就会出错），形成一个新的字符串。

　　　　　

　　　　5.str与bytes类型的转换

　　　　str---->bytes　　encode方法；s.encode('utf-8')或('gbk')

　　　　bytes---->str　　decode方法；s.decode('utf-8')或('gbk')

　　　　6.元组与列表的转换

　　　　tuple--->list　　list(tuple)

　　　　list--->tuple　　tuple(list)

　　　　7.集合与列表的转换

　　　　set--->list　　list(set)

　　　　list--->set　　set(list)

三、数据类型

　　 基础数据类型引言：

　　　数据类型的分类：

　　　　　　可变数据型（不可hash）：list,dict.set　

　　　　　　不可变数据（可hash）：int,bool,str,tuple

　　　容器类型：

　　　　　　容器类（承载各种数据类型）：list，tuple,dict

　　 （一）int 运算。+ - * / ** % ...

　　  #bit_lenth 方法

　　　　i = 4

　　　　print(i.bit_lenth())

　　　　# 转化成二进制的最小位数。

　　  （二）bool：判断，真假，作为条件

　　  （三）str（字符串） 存储少量的数据。  操作简单，便于传输。

　　　　1、str的索引与切片

　　　　（索引出来的数据，之前是什么类型，索引出来还是原来的类型；

　　　　　　切片形成的数据，对谁（list，str，tuple）进行切片，之后还是

　　　　　　原先（list，str，tuple）的数据类型）

　　　　　a.字符串的拼接

　　　　　　字符串可以进行相加和相乘

　　　　　b.字符串在内存中的存储

　　　　　　n="oldboy"　　如果是汉字，编码不同，则占用的字节不同。

　　　　　　一个字母会占用一个字节，最后加一个'\o'；即n一共占用8个字节。()

　　　　　c.字符中的下标，索引

　　　　　　n="oldboyOLDBOY"  下标是用0开始；n[0]的输出是"o";n[-1]的输出是"Y"

　　　　　d.字符串的切片、逆序

　　　　　　[索引初值:索引终值:步长] （默认的步长是1）（原则就是顾头不顾尾）

　　　　　　n[1:4] 的输出是“ldbo”

　　　　　　n[2:]第一个：后面什么都不写，会取到最后一个字符；输出的是：“dboyOLDBOY”

　　　　　　n[2:-1:2]步长=2，跳一个，取一个；输出的是：“doODO”

　　　　　　n[::-1]表示逆序，起始值什么不写，可能是第一个也可能是倒数第一个；如果步长是-1就表示逆序。输出的是：“YOBDLOyobdlo”。

　　　　2、字符串（str）的使用方法　　(通过查看源码，学习其他方法)

 1.captalize(首字母大写)；title(每个单词首字母大写)
 2 ps:
 3     s = 'laonahai'         
 4     print(s.captalize())
 5     
 6     s = 'lao nan,hai7is' (以空格数字特殊符号非字母认为是分开的单词)   
 7     print(s.title())
 8 
 9 2.upper(全部大写)；lower(全部小写)
10     s = 'laonahai'         
11     print(s.upper())
12 
13     s = 'laonahai'         
14     print(s.lower())
15 
16 3.swapcase(大小写翻转)
17     s = 'laOnaHai'                
18     print(s.swapcase())
19 
20 4.center(20,"$")内容居中，总长度，空白处填充
21     s = 'laonahai'         
22     print(s.center(25,"*"))
23 
24 5.startswith(判断以什么开头)；endswith(判断以什么结尾)
25      s = 'laonahailaonahai'         
26      print(s.startswith('l')   
27      ()内的参数必须是一个整体，不能调隔；可以传切片（start和end）参数。
28 
29 6.strip(去除首尾的空格，/n ,/t)   lstrip(去除左边的) rstrip(去除左边的)
30     s = ' \n laonahai \t '         
31     print(s.strip())
32 
33 7. find(通过元素查找索引)；找不到时会返回一个"-1"
34     index(通过元素查找t(s.startswith('l') 
35      s = 'laonahailaonahai'         
36      print(s. find('l',1,9)      可以传切片（start和end）参数。
37 8.count(寻找元素出现的个数，可切片)
38      s = 'laonahailaonahai'         
39      print(s.count('l',3,12) 
40 9.replace(替换)
41     s = 'laonahailaonahai'         
42      print(s.count('l','m') 
43 10. split 分割  str ---> list
44      s = 'alex wusir taibai'
45     print(s.split())
46     s1 = 'alex,wusir,taibai'
47     print(s1.split(','))
48     s2 = 'alexawusirataibai'
49     print(s2.split('a'))（会把a干掉）
50     s3 = 'alexawusirataibai'
51     print(s3.split('a',1))  # 分割次数
52 
53 11.format(格式化输出)
54     三种用法
55     第一种用法：
56     s = '我叫{}，今年{}，爱好{}'.format('MT',18,'母牛')
57     print(s)    **{}中间不能有空格，否则报错
58     第二种用法
59     s = '我叫{0}，今年{1}，爱好{2}，我依然叫{0},今年还是{1}'\
60     .format('MT',18,'母牛')    **{}内的数字依据format()内的个数来填写；在这里不能超过2，填3就会报错。
61     print(s)
62     第三种 键值对
63     s = '我叫{name}，今年{age}，爱好{hobby}'.format(age=18, name='MT', hobby='闷儿')
64  
65 12.isalnum,isalpha,isdigit
66     name='123a'
67     print(name.isalnum()) #字符串由字母或数字组成
68     print(name.isalpha()) #字符串只由字母组成
69     print(name.isdigit()) #字符串只由数字组成
70     if name.isdigit():
71         name = int(name)
72         print(name,type(name))
73     else:
74         print('您输入的由非数字元素')

　　　strip()的注意点：

 

　　（四）list  列表 存放大量的数据，大量的数据放在列表中便于操作。而且列表有序，有索引值，可切片，方便取值

　　　　A.列表定义：

　　　　方法一：names =  [1，2，"qwe"，{"name":"老男孩"},[3.14，55,66]]

　　　　方法二：names =  list('qwer')　　迭代的添加方法；会生成这样一个列表 ['q', 'w', 'e', 'r']

　　　　方法三：names = list(['qwer',8,9,7])

　　　　B.增删改查：

复制代码
增：
1.append：一次只能添加一个，追加到最后一个元素。
2.insert：指定索引位置添加，一次只能添加一个元素。
3.extend：迭代的添加，到列表最后。
删：
pop：按照索引值删除，一次只能删除一个，
remove：按照元素删除，一次只能删除一个。
clear：清空列表
del list：删除列表    /del list[索引值]可切片。
改：
1.[索引值] = new，通过索引赋新值。
2.[切片] = new，通过切片的改回迭代的条件到列表中。
查：
1.[]索引或切片查
2.循环查

补充：
in    not in 判断列表中是否存在该元素。
复制代码

删的pop和remove一侧只能删除一个；切片删除用 del list[:]

　　　　C.列表的方法：

　　　　　　可以索引值，切片，步长，

　　　　其他操作方法：

　　　　1，sort 从小到大， 正向排序

　　　　　　l1 = [1, 2, 1, 7, 5, 4, 9, 8, 3]

　　　　　　l1.sort()

　　　　2，从大到小，反向排序

　　　　　　l1.sort(reverse=True)

　　　　3.翻转　　#str或int类型都可以

　　　　　　l1.reverse()

　　　　4.len 长度　　len(l1)

　　　　5.index  通过元素找索引  ；(列表只有index方法；没有find方法。)

 　　　　D.列表的嵌套：列表再有列表

 　　　　li = [1,2,'alex',['100','wusir',99,[44]],22]　　

　　　　　

li = [1,2,'alex',['100','wusir',99],22]
li[2] = li[2].capitalize()
#print(li)
li[3][1]=li[3][1].upper()
print(li)
li [3][2] = 99+1
print(li)

列表嵌套查询的方法：li.[索引值][索引值]

　　　　E.在循环一个列表是，最好不要进行删除操作，（一旦删除，索引会随之改变，容易出错）

　　　　eg：li = [11,22,33,44,55]将索引为奇数的元素删除。

　　　　方法1：用切片删除

　　　　　　del li[1::2]

　　　　方法2：定义一个空列表，for循环出每一个奇数元素，添加到空列表中，再赋值给原先的列表。　　li = [11,22,33,44,55]

　　　　　l2 = []

　　　　　for i in range(len(li)):

　　　　　　if i%2==0:

　　　　　　　　l2.append(li[i])

　　　　　　li = l2

　　　　方法3：倒序删除

　　　　　　for i in range(len(li)-1,-1,-1):

　　　　　　　　if i %2 == 1:

　　　　　　　　　　del li[I]

　　备注：列表中不使用多行注释

　　　　（五）tuple 元组   只读列表。(1,2,{"name":"老男孩"})数据可以被查询，不能被修改。所以，字符串的切片同样适用于元组。

　　　　A.创建：ages = ()

　　　　　　　　ages = tuple(())

 　　　　儿子不能改，孙子可以改：如果元组中有列表、字典等，可以修改的元素，那么列表等可以进行修改。

　　　　B.常用操作：

　　　　索引，切片，循环，长度，包含（in  not in）

　　　　C.对于元组：如果只有一个元素，并且没有逗号　　；t = (2)　　<==>t = 2

　　　　　此元素是什么数据类型，该表达式就是什么数据类型。　t = (2,)　则是一个元组　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　（六）dic 字典  存储关系型的数据，查询速度非常快，二分查询。

　　　A.字典的定义：python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无须存储，（3.5之前；3.6以后的版本，字典在创建的时候，按照一定的顺序插入的数值，看起来是有序的。）

　　　B.列表是有序的对象集合，字典是无须的对象集合，两只之间的区别在于：

　　　　字典当值的元素是通过键来存储，而不是通过偏移存储。

　　　　　创建：info = {key1:value1,key2:value2}

　　　　　　1.键与值用“:”冒号分开

　　　　　　2.项与项用“,”号分开

　　　　　创建方法：1.person = {'name':'les','age',18}

　　　　　　　　　　2.person = dict(name='les','age'=19)

　　　　　　　　　　3.preson = dict({'name':'les','age',18})

　　　　　　　　　　4.dic = dict([("k1", "v1"), ("k2", "v2")])　　有序字典：OrderedDict([("k1", "v1"), ("k2", "v2")])

　　　　　特性：

　　　　　　1.key-value结构

　　　　　　2.key必须可hash，且必须为不可变类型，必须唯一

　　　　　　3.可存放任意多个值，可修改，可以不唯一。

　　　　　　4，无序。（3.5之前；3.6以后的版本，字典在创建的时候，按照一定的顺序插入的数值，看起来是有序的。）

　　　　　info= {"name":"班长"，"addr":"山东"，"age":18}

　　　　　　print("%s %d %s"%(info["name"],info["addr"],info["age"]))

　　　　注意：

　　　　　　

 

　　　c.增删改查：

增：

　　　　第一种：给key赋value（有则覆盖，无责添加）

　　　　　　dic['key'] = 'value'

　　　　　第二种：.setdeafult（有则不变，无责添加）

　　　　　　　dic.setdefault()

　　　　删：

　　　　第一种：.pop()　　 有返回值的

　　　　　　dic.pop('key')　　根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值。eg：print(dic.pop('na','没有此键'))　　如果dic中没有'na'这个值，后面可以再自己定义一个参数，提示出，没有'na'这个key值对。


　　　　　第二种：.popitem()　　随机删除，有返回值。
　　　　　dic.popitem()
　　　　第三种:.clear　清空
　　　　　dic.clear
　　　　第四种：del　　删除字典；也可以带入key,删除键值对
　　　　　　del dic
　　　　　　del dic['key']
　　　改:
　　　　第一种:给key赋value（有则覆盖，无责添加）
　　　　dic['name'] = '太黑'
　　　　第二种：.update方法　　两个字典的改，
　　　　dic = {"name":"jin","age":18,"sex":"male"}

　　　　dic2 = {"name":"alex","weight":75}

　　　　dic2.update(dic)  # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
　　　　　查：

　　　　第一种:print(dic['name'])　　通过key来查看，value

　　　　　第二种：.get方法

　　　　　print(dic.get('name1')) # 默认返回None

　　　　　print(dic.get('name1','咩有此键值对')) # 默认返回None

　　　D.其他方法：

　　　　1.keys()　　values()　　items()

　　　　　　print(dic.keys())

　　　　　　#for i in dic.keys:　　#<==>for i in dic:

　　　　　　　　print(i)#　　循环key

　　　　　　keys = dic.keys()

　　　　　　print(keys,type(keys)) 

　　　　　　dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>特殊的字典类列表。

　　　　　　print(dic.vaules())

　　　　　　......

　　　　　　dic.items()　　key.value都打印出来

　　　　2.字典的　　fromkeys(*args, **kwargs)方法：　　*args必须是一个可迭代对象。

　　　　dic = dict.formkeys('abc','alex')　　#会把abc迭代的添加到字典中，对应的每一个值都是'alex'

　　　　dic = dic.formkeys([1,2,3],[])　　#先生成{'1':[],'2':[],'3':[]}

　　　　dic[1].append('老男孩')　　　　#再分别把'老男孩'添加到每一个字典的值中。

　　　　dic[1] = 777　　#则改变的只有dic[1]的值是777；其他都是'老男孩'

v = dict.fromkeys(['k1','k2'],[])
   v[‘k1’].append(666)
   print(v){'k1': [666], 'k2': [666]}
   v[‘k1’] = 777 # 单独对k1进行赋值
   print(v){'k1': 777, 'k2': [666]}

　　　　　　循环键值对

　　　　　　1.for i in dic.items:　　2.for k,v in dic.items():　　　3.　for i in dic:

　　　　　　　　　print(i)　　　　　　print(k,v)　　　　　　　　　　print(i,dic[i])　　

　　　　　　2.长度：len(dict)　

　　　　E.字典的嵌套

　　　　　　dic = {"name_list":['张三','lisi','隔壁王叔叔'],'dic2':{'name':'太白','age':12}}

　　　　　　1 ,给列表追加一个元素：'旺旺'

　　　　　　　　dic['name_list'].append('旺旺')

　　　　　　2,给列表lisi全部大写

　　　　　　　　dic['name_list'][1] = dic['name_list'][1].upper()

　　　　　　3，给dic2 对应的字典添加一个键值对：hobby：girl

　　　　　　　　dic['dic2']['hobby'] = 'girl'

　　　　　　　　dic['dic2'].setdefault('hobby','girl')

　　　　F.在循环字典中，不能增加或删除此字典的键值对。(字典中不能有重复的key，循环添加会被覆盖)

　　　　eg：dic = {'k1':'value1','k2':'value2','name':'wusir'}

　　　　将字典中含有k元素的键，对应的键值对删除。

　　　　解决方法：把包含K元素的键，添加到列表中；再循环列表时，删除键值。

li = []
for i in dic:
    if 'k' in i:
        li.append(i)
for i in li:
    del dic[i]
print(dic)

for i in list(dic):
    if 'k' in i:
        del dic[i]
print(dic)

　　　　set 集合  交集，并集，补集...

　　集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）

　　　但是：frozenset不可变集合，让集合变成不可变类型。也就可以做字典的key了。frozenset转换之后，里面的还是无序的({'a', 'y', 'b', 'r'})

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

 　　　　集合的两个重要应用：

　　　　1.去重，把一个列表变成集合，会自动去除列表的重复元素；

　　　　2.关系测试，测试两组数据之间的交集，差集，并集等关系。

1.集合的创建、形式

　　创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。　

　　有元素集合set 1= {1,2,3}　　

2.集合的增

set1.add()

set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)

set1.update()

set1.update('abc')
# set1.update([1,2,3])
# print(set1)

3.集合的删

set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

set1.discard('alex')　　<==>  remove

4.集合的其他操作

4.1 交集。（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　4.2 并集。（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

　　4.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

 　　4.4反交集。 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　4.5子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

集合set的查询：集合是无许的，只能通过循环的方式查询。