The new week-学习Python-第一周

Posted 2020-08-31

记录自学Python心得

之前有一段时间的JAVA自学，但最终以“无目标”的状态下被懒散驱散了动力，此为前提

Python的历程就不细细说道了，蛮有趣的

一般大家都是学习的CPython，速度较快（这个大家应该都知道吧）

好吧，开始我们的基础级基础学习吧：

老一套的开头--

第一个Python程序输出“Hello World”

print(‘Hello World‘)

 Python3.0要求必须在打印时输入小括号，相对2.x来说是规范了些

哦 对了  在Python里，‘’和“”是没有任何区别的啦，除非中间的字符串带有‘或者”，别告诉我你看不出来这是单/双引号

之后就是数据类型了（至于什么字节码啊 机器码啊 解释器之类的执行流程可自行百度哦）

共六大类：

1.数字（int,Long,Float..）

　　int---指整型数字，一般用到小数据的话就用int类型就足以

　　Long---指长整型，大数据的情况下需要用到，就是很长很长的数字

　　Float---指浮点型，意指小数

　　bool---布尔类型，True和False喽，也就是0或者1，二进制起步就是从这开始的　

2.字符串（String）

     就是类似‘Hello World’之类的字符啦

3.列表（List）

    Python默认有List相关的方法定义，故可以直接用。

    一般用法如下：

name_list=[‘Alex‘,‘jack‘,‘smone‘,‘1001‘]   #定义一个列表
name_list.append(‘1001‘)      #添加值到最后一位
#del name_list[0]              #删除某个索引的值
name_list[2]=‘1001‘           #替换某个索引的值
#name_list.sort()              #正序排列
name_list.pop()                #删除最后一位元素
#name_list.remove(‘Alex‘)      #删除特定元素
x=name_list.count(‘1001‘)     #计算某一元素在列表内的个数
name_list[1:2]=[]              #将1号元素删除为空
print(x)
print(name_list)
print(name_list[:-2])           #打印从0到-1之间的值
print(name_list[:1])            #打印从0到0的值
print(name_list[2:])            #打印从2到6之间的值
print(max(name_list))          #打印列表内最大的值

运行结果：
2
[‘Alex‘, ‘1001‘, ‘1001‘]
[‘Alex‘]
[‘Alex‘]
[‘1001‘]
Alex

List_review

    列表内元素是可以改变的，删除和更改某个索引的值

    name_list.insert(0,‘jack‘)    #意指在第0个位置添加值‘Jack’

4.元祖（Tuple）

    元祖跟列表类似，但元祖内的数值是不可改变的（不可删除，更改值，排序）

p=tuple()          #创建一个元祖p
p=(‘jack‘,‘11‘,‘22‘,‘Tom‘)
print(type(p))      #查询格式
ret=p.count(‘22‘)   #计算元素出现的次数
print(ret)
rat=p.index(‘22‘)   #查询某个值的索引
print(rat)

运行结果：
<class ‘tuple‘>
1
2

Tuple_review

5.字典（Dict）

    字典基础就是{‘k1‘:‘v1’,‘k2‘:‘v2‘,‘k3‘:‘v3‘}，由键值对组成，键（keys）值（values）

    其中包含基本方法三个：items()，keys()，value()

    首先看下Python内置的Dict的方法：

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object‘s
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
    def clear(self): # real signature unknown; restored from __doc__  #清除字典里的所有值
        """ D.clear() -> None.  Remove all items from D. """
        pass

    def copy(self): # real signature unknown; restored from __doc__   #浅拷贝该字典
        """ D.copy() -> a shallow copy of D """
        pass

    @staticmethod # known case
    def fromkeys(*args, **kwargs): # real signature unknown
        """ Returns a new dict with keys from iterable and values equal to value. """
        pass

    def get(self, k, d=None): # real signature unknown; restored from __doc__   
        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
        pass

    def items(self): # real signature unknown; restored from __doc__    #一个keys和values对应的就是一个item
        """ D.items() -> a set-like object providing a view on D‘s items """
        pass

    def keys(self): # real signature unknown; restored from __doc__      #取所有的key
        """ D.keys() -> a set-like object providing a view on D‘s keys """
        pass

    def pop(self, k, d=None): # real signature unknown; restored from __doc__    #将某个key的value拿出来
        """
        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        If key is not found, d is returned if given, otherwise KeyError is raised
        """
        pass

    def popitem(self): # real signature unknown; restored from __doc__    #将最后一组键值拿出来
        """
        D.popitem() -> (k, v), remove and return some (key, value) pair as a
        2-tuple; but raise KeyError if D is empty.
        """
        pass

    def setdefault(self, k, d=None): # real signature unknown; restored from __doc__   #查找某个key的value，若不存在该key则返回为none
        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
        pass    

    def update(self, E=None, **F): # known special case of dict.update   #将某个字典添加到另外一个字典中去
        """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]
        """
        pass

    def values(self): # real signature unknown; restored from __doc__    #同keys()
        """ D.values() -> an object providing a view on D‘s values """
        pass

Dict_class

   下面是一些实例：

dic=dict()           #定义一个字典类型
dic={‘cod‘:‘sudo‘,‘xia‘:‘zha‘,‘you‘:[‘jack‘,‘22‘]}    #创建一个字典，value可为列表或元祖
print(dic.keys())            #打印所有的key
d=dic.values()               #定义value为d
print(d)                     #打印d，即所有的values
dic[‘name‘]=‘laji‘          #在右边添加key和value
dic[‘cod‘]=4                 #更改某个key的值
a=dic.popitem()              #取出最后一对键值
a1=dic.pop(‘xia‘)            #删除key对应的value
dic1={‘k1‘:‘v1‘}
b=dic.update(dic1)           #将字典添加到另外一个字典里
print(dic)
c=dic.setdefault(‘cod‘)      #查找某个key的value值
d=dic.setdefault(‘llkl‘)     #若不存在返回none
print(dic)
print(a)
print(a1)
print(c)
print(d)


运行结果：
dict_keys([‘cod‘, ‘xia‘, ‘you‘])
dict_values([‘sudo‘, ‘zha‘, [‘jack‘, ‘22‘]])
{‘cod‘: 4, ‘you‘: [‘jack‘, ‘22‘], ‘k1‘: ‘v1‘}
{‘cod‘: 4, ‘you‘: [‘jack‘, ‘22‘], ‘k1‘: ‘v1‘, ‘llkl‘: None}
(‘name‘, ‘laji‘)
zha
4
None

Dict_review

6.集合（Set）

   所谓集合就是无序的元素的合集

   基本用法：

   

a=set(‘python‘)
print(type(a))      #查看集合的类型
print(a)
a.add(‘j‘)  #添加一个值到集合里
print(a)
a.remove(‘o‘)   #移除一个值
print(a)
a.update(‘jack‘)  #添加一个字符串到集合
print(a)
del a             #删除

运行结果：
<class ‘set‘>
{‘p‘, ‘y‘, ‘n‘, ‘t‘, ‘o‘, ‘h‘}
{‘p‘, ‘y‘, ‘n‘, ‘t‘, ‘o‘, ‘h‘, ‘j‘}
{‘p‘, ‘y‘, ‘n‘, ‘t‘, ‘h‘, ‘j‘}
{‘p‘, ‘y‘, ‘n‘, ‘t‘, ‘a‘, ‘h‘, ‘k‘, ‘j‘, ‘c‘}

Set_review

 ---------------

当然还有len()啦，它的用法就是数下所有元素的个数，在以上类型中均有用到