RomanticQq

保持对生活的热爱，唯有生活不可被辜负

0%

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 1.4k 阅读时长 ≈ 1 分钟

运算符

  1. 算术运算符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    +:加
    -:减
    *:乘
    /:除(结果可以是float)
    %:取余
    **:幂运算 eg: print(2**3) #打印2的3次幂
    //:整除(向下取整)
    注：
    # 可用幂运算进行开方运算
    eg:print(81**(1/2)) #打印的是81开平方的结果，即为9
    # 在Python2中，/得到的是一个整数;在Python3中得到是一个浮点数
    # 在开发中使用括号来表示优先级,比较清晰

  2. 算术运算符在字符串中的使用

    1
    2
    3
    4
    5
    # 在字符串中有限度的支持加法和乘法运算符
    print("hello"+"world")   # 结果为 helloworld(用于拼接字符串)
    print("hello"*2)         # 结果为 hellohello
    注：字符串和数字是不能相加的
    print("a"+1) # 会报错

  3. 赋值运算符

    1
    2
    3
    4
    a=1 # 单个变量赋值
    m,n=1,2 # 多个变量赋值(拆包),且当等号左右两侧个数不相等时会报错
    o*,p,q=1,2,3,4,5 #加*表示可变长度,把4,5分别赋给p,q,其余全部赋值给o
    m='hello','world' # 元组赋值

  4. 比较运算符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 比较运算符
    >:大于
    <:小于
    >=:大于等于
    <=:小于等于
    !=:不等于(在python2<>也表示不等于，python3不支持)

    # 比较运算符在字符串中的使用
    print('a'<'b') # 结果为true 按照ASCII码进行比较
    print('abc'<'b') # 结果为true,直接字符a,b相比得出结果
    print('abc'=='abc') # 结果为true
    在数字和字符串之间做==为true,做!=比较为false

  5. 逻辑运算符

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    and:逻辑与
    or:逻辑或
    not:逻辑非

    #规则
    逻辑与规则:只有一个运算数是False,结果就为False
    逻辑或规则:只有一个运算数是True,结果就为True
    优先级:not > and > or

    #逻辑运算符的取值问题(逻辑运算结果不一定是bool值)
    print(3 and 'Hello' and 0 and 2) 
    # 结果为0(按照逻辑与的运算规则,有False则False)
    print(3 or 0)
    # 结果为3,逻辑或运算当有一个是True时，后面的将不会被执行

    #逻辑运算符的短路问题
    4 > 3 and print('hello world') 
    # 打印hello world
    4 > 3 or print('hello world') 
    # print将会短路，因为逻辑或前面已经是True,后面将不会被执行

  6. 位运算

    1
    2
    3
    4
    5
    6
    7
    8
    &:按位与(都为1取1,否则取0)
    |:按位或(有1取1,否则取0)
    ^:按位异或(不同取1,相同取0)
    ~:按位取反(0取1,1取0)
    <<:左移(向左移,后面补0)
    >>:右移(向右移,数据会丢失)
    # 左移:x左移a位结果为x乘以2的a次方
    # 右移:x右移a位结果为x除以2的a次方(取整)

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 1.6k 阅读时长 ≈ 1 分钟
  1. 函数定义语法
    1
    2
    3
    4
    5
    # def 函数名(参数):
    #    函数要执行的语句
    eg:
    def say(person):
        print('{}说：他明天去旅游'.format(person))
  2. 传参
    1
    2
    3
    4
    # 1.一一对应传参
    say('xiaoming')
    # 2.通过变量名给形参赋值
    say(person='xiaoming')
  3. 返回值
    1
    2
    3
    4
    1. return a #语法
    2. 通常情况下只能return一次
    3. 如果一个函数没有返回值，那么它的返回值就是None
    4. 在特殊情况下(finally语句)，一个函数可能会执行多个return语句
  4. 函数的注释
    1
    2
    3
    4
    5
    6
    在定义函数名的下一行按三对双引号，然后回车
    """

    :param person:
    :return:
    """
  5. 全局变量和局部变量
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    1. 定义在函数外的为全局变量
    2. 定义在函数内的为局部变量
    3. 如果局部变量和全局变量重名时，会在函数内部又定义一个新的局部变量，而不是修改变全局变量
    4.如果在函数内部想要修改全局变量，则用global
    eg：想要在函数内部修改全局变量name
    global name
    name='xiaoming'
    5.使用内置函数查看全局变量和局部变量
    globals() # 查看当前.py中的全局变量
    locals()  # 查看当前.py中的局部变量
    6. 在Python中只有函数分作用域
  6. 函数多个返回值
    1
    2
    3
    4
    5
    6
    7
    8
    1. 函数返回多个结果，就是将多个数据打包成一个整体返回，可以使用列表和字典
    2. 通常情况下使用元组
    3. 接受多个返回值时，若一直返回值个数，可直接用变量分别接受
    eg:
    def test():
        return 1,2
    x,y=test()
    print('x={},y={}'.format(x,y))
  7. 缺省参数
    1
    2
    3
    4
    5
    6
    定义：有些函数的参数是有默认参数，你传了用你的，不传用默认的
    eg:
    def say(person='xiaoming'):
        print('{}说：他明天去旅游'.format(person))

    say() # 当say函数不传参数时，就使用默认参数
  8. 特殊传参
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    1. 当位置参数和关键字参数混合使用时，位置参数在前
    eg:
    say('xiaoming',age=18)  # 位置参数前，关键字参数后

    2. 位置可变参数
    def say(name,*args):
        pass

    say('xiaoming')  # args为空
    say('xiaoming',18)  # 18以元组的形式存在args里
    # 多出来的可变参数会以元组的形式保存在args里
    # 在定义函数参数时,先写位置参数再写可变位置参数，传参时也是
    # 注意是一个*

    3.可变关键字参数
    def say(name,**kwargs):
        pass

    say(name='xiaoming')  # kwargs为空
    say('xiaoming',18)  # 18以元组的形式存在kwargs里
    # 多出来的可变参数会以字典的形式保存在kwargs里
    # 在定义函数参数时,先写位置参数再写可变位置参数，传参时也是
    # 注意是**

    4.当位置参数，可变位置参数，缺省参数，关键字参数，可变关键字参数同时出现时
    def say(位置参数，可变位置参数，缺省参数，关键字参数，可变关键字参数)  
    #传参时也是一样
  9. 注意事项 
    1
    2
    1. 在Python中函数不允许重名,重名后一个会覆盖前一个
    2. 函数名和变量名也不能重名

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 3.1k 阅读时长 ≈ 3 分钟

  1. 元组

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    # 元组和列表很像，用来保存多个数据
    # 使用一对小括号(),来表示一个元组
    # 元组是不可变数据类型,因此只能进行查，不能进行增删改
    # 元组是一个有序的存储数据的容器，可以通过下标来获取元素
    # 元组也可以遍历

    index # 通过下标获取元素
    count # 用来统计指定元素的个数
    x=(1,)  #表示只有一个元素的元组
    tuple   # 实现可迭代对象转化为元组(列表list也可以这样用)

  2. 列表

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    1. 当我们保存多个数据时可以使用列表(列表近似于C语言的数组)

    2. 使用[]表示一个列表，列表里的每一个数据表示元素，中间用逗号隔开
    ['xiaoming',18,'河南'] # 即表示一个列表，数据类型可以不同

    3. 可以使用list(可迭代对象),将可迭代对象转换成一个列表
    eg：
    x=list(('张三','李四','王五'))
    print(x) # 打印结果：['张三', '李四', '王五']

    4. 可以通过下标获取修改列表即对列表进行切片
    注：A[m:n] # 例如在对a进行切片时,从下标m开始,不包含下标为n的

    5. 增加列表元素
    append # 在列表末尾加一个元素
    insert # 在指定位置插入元素
    extend # 将可迭代对象添加到末尾

    6. 删除列表元素
    remove # 删除列表指定元素
    clear # 清空列表
    del #删除一个列表元素
    pop #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

    7. 查询列表元素
    index # 返回指定元素下标,不存在会报错
    count # 返回指定元素的个数

    8. 修改元素
    用下标定位到元素,直接赋值

    9. 调用列表的sort方法进行排序
    顺序排序:默认循序排序
    逆序排序:x.sort(reverse=True)

    10. 内置函数sorted排序
    新生成一个列表
    # 注：sort排序是改变原列表的序列,sorted新生成一个列表

    11. 列表逆序
    reverse:用函数
    x.[::-1]:用切片法

    12. 复制列表
    y=x # x,y指向了同一个内存地址,会相互影响
    copy # 新列表和原列表数据相同,内存地址不同,不会相互影响

    13. 使用for...in对列表进行循环遍历时,尽量不要对列表进行删除操作

    14. 列表的嵌套
    [1,2,[3,4],[4,5,6]] # 列表可以嵌套使用

    15. 带下标进行for...in循环(一般用while)
    for i,room in enumerate(rooms) # enumerate是关键字

    16. 列表推导式
    # 用列表推导式创建一个列表,产生列表条件简单的时候使用
    nums=[i for i in range(10)] # 产生0-9,这10个数据的列表

    17. 列表合并
    extend # 将两个列表合并成一个列表

  3. 字典

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    # 字典里的数据都是以键值对的形式保存的
    # key,value之间使用冒号连接，多个键值对之间使用逗号连接
    # key是不允许重复的,重复了后一个会覆盖前一个
    # key只能是不可变数据类型，而value可以是任意数据类型

    # 1.查找数据(因为字典是无序的数据类型,所以只能用key来查找值)
    x['key'] # 查找不到会报错
    x.get['key'] # 查找不到会默认返回None
    x.get['key',default] # 查找不到返回default

    # 2.修改和删除(若存在key则修改,不存在则删除)
    x['key']=value

    # 3.删除
    pop('key') # 删除并返回,否则返回默认值
    pop('key',default) # 删除并返回,否则返回default
    popitem() # 返回并删除字典中的最后一对键和值
    clear() # 清空字典
    del x['key'] # 直接删除,无返回值

    4.合并
    A.update(B) # A,B合并成一个字典,并赋值给A

    5.循环
    方法一:直接for...in循环遍历字典
    for k in x: # for...in循环遍历获取的是key
        print(x,'=',x[k])

    方法二:获取所有的key,再由key获取value
    for k in x.keys(): 
        print(x,'=',x[k])
    # 一般不用这种方法,和方法一几乎相同,多此一举

    方法三:获取所有的value
    for v in x.values():
        print(v)

    方法四:拆包获取key,value
    for k,v in x.items():
        print(k,'=',v)
    # 常用方法一和四

    6. 交换key和value的位置
    方法一:
    x1={'name':'xiaoming'}
    x2={}
    for k,v in x1.items():
        x2[v]=k
    方法二:字典推导式
    x={'name':'xiaoming'}
    x1={v:k for k,v in x.items() }
    print(x1)

    7.字典推导式
    x1={v:k for k,v in x.items() }

  4. 集合

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    # 集合是一个不重复的无序的数据类型
    # 集合可以用{}或set表示
    # {}有两种意思:字典、集合;当里面的数据不是键值对时表示字典
    # 字典中不允许有重复元素,当有重复元素时会自动去重

    1.增加元素
    add() # 增加一个元素

    2.清空集合
    clear() # 清空集合
    set() #表示空集合
    {} # 表示空列表

    3. 删除元素
    pop # 随机删除一个
    remove # 指定删除一个,若删除的元素不存在则会报错

    4. 合并
    union # 两个集合合并在一起,生成一个新的集合
    A.update(B) # 将B拼接在A里
    # 被合并的那个是可迭代对象即可

    5. 集合支持很多运算符(但不支持加法)
    A-B # A与B的差集,就是去掉A中,B中有的元素
    A&b # A与B的交集
    A|B #A与B的并集
    A^B #A和B差集的并集(即去掉AB中共有的元素,把其余的合并在一起)

    6. 特殊情况
    # 当列表转化为集合,如果是数字会去重且自动按升序排序

  5. 元组、列表、字典的区别

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    1.元组(Tuple)
    # (),有序，元素任意，元素不可变

    2.列表(List)
    # [],有序，元素任意，元素可变
    # 与C语言的数组相似，不同的是C语言的数据类型要相同，list可以不同

    3.字典(Dictionary)
    # {}，无序，元素任意，元素可变
    # 元素键值对存在

    # 列表用extend合并,字典用update合并
    # 元组和列表可以用加号使两个元组和列表合并成一个，字典不可以

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 1.6k 阅读时长 ≈ 1 分钟

分支语句

  1. if

    1
    2
    3
    4
    5
    if 判断条件:
        条件成立时，执行的语句
    eg:
    if 1 < 2 :
        print("helloworld")

  2. if…else

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    if 判断条件:
        条件成立时，执行的语句
    else
        当if中的条件不成立时，执行的语句
    eg:
    msg=1
    if msg==0 :
        print("helloworld")
    else:
        print("你好")
    eg:
    if 1 < 2 :
        print("helloworld")

  3. if…elif…else

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    if 条件1:
        条件1成立，执行语句
    elif 条件2:
        条件2成立，执行语句
    else:
        当所有条件都不成立时，执行的语句
    eg:
    msg=10
    if 0 <msg<3 :
        print("helloworld")
    elif 3<= msg <=10 :  #在Python中，允许这样进行左右判断
        print("你好")
    else:
        print(msg)

  4. pass关键字

    1
    2
    3
    4
    # pass关键字在Python中没有意思，只是用来占位，保证代码的完整性
    eg:
    if 1 < 2 :
        pass   # pass无意义，保证代码完整性

  5. if语句注意点

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    1.区间判断
    在Python中可以进行连写判断,如 0<=msg<=10
    2.隐式类型转换
    if后面需要一个bool类型的值，若不是bool类型的值，则会自动转换
    eg：
    if 1 :
        print("你好") # 1会自动转换成bool类型的值true
    3.三元表达式(对if...else的简写)
    x=num1 if num1 > num2 else num2
    eg:
    x=1 if 1 < 2 else 2 
    print(x)   # 打印出的结果为1
    4. 在Python中不支持switch...case...
    5. 在Python中使用强制缩进来表示语句之间的结构

循环语句

  1. while循环

    1
    2
    3
    4
    5
    while 判断条件:
        条件成立时,执行的语句
    eg:
    while 2<3:
        print("hello world")

  2. for循环

    1
    2
    3
    4
    5
    for ele in iterable:
        执行语句
    #这个和别的语言有所区别,对于计算数的时候一般用range
    for i in range(0,5):
        print(i) # 打印结果为0,1,2,3,4

  3. for…in循环

    1
    2
    3
    4
    5
    6
    # for...in循环的本质是不断的调用next方法查找下一个数据
    for ele in iterable:
        执行语句
    eg:
    for i in range(1,5):
        print("aaa")

  4. for…else循环

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    for ele in iterable:
        执行语句
        if 条件判断:
            break   # 若break被执行，则退出for...each循环，each不会被执行
    else:
        执行语句 # 当for语句执行完后且没有被break,则最后再执行each语句
    eg:
    for i in range(1,5):
        print("aaa")
        if i==3:
            break
    else:   # 当for里面break被执行，each就不会被执行
        print("111")

  5. break和continue

    1
    2
    break:终止本层循环
    continue:终止本次循环

  6. 循环语句注意事项

    1
    2
    3
    4
    5
    1. Python中没有i++或i--,只能i+=1
    2. 常用range内置类生成一个整数区间进行循环
    3. range生成的整数区间以前一个数开始，以后一个数的前一个整数结束
    4. in后面是一个可迭代的对象,目前接触到的接迭代的对象:字符串,列表,字典,元组,集合,range
    5. Python中没有do...while...

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 79 阅读时长 ≈ 1 分钟
  1. 在Python2中，/得到的是一个整数;在Python3中得到是一个浮点数
  2. 在python2中0o和0开始的数字都是8进制;在Python3中只有0o表示8进制

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 734 阅读时长 ≈ 1 分钟

  1. 二、八、十六进制转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
      二进制:前缀,0b;0b11;每个位最大不能超过1
      八进制:前缀,0o;0o17;每个位最大不能超过7
    十六进制:前缀,0x;0x1f;每个位最大不能超过f
    # 注：在python2中0o和0开始的数字都是8进制

    # 手算转换
    2进制转换为8：从后向前3位一组进行
    2进制转换为16：从后向前4位一组进行
    2,8,16进制转换成十进制，都是按照幂次，然后相加进行计算
    10进制转换成2进制：除留余数法

    # 机算
    a=12 #10进制数
    bin(a) # 将10进制数转换成2进制
    oct(a) # 将10进制数转换成8进制
    hex(a) # 将10进制数转换成16进制
    注：当a不等于数字时会报错
  2. 数据类型之间的转换
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #转换函数
    msg=int(msg) 
    # 将不是int型的变量转换成int型的变量
    # 其余类型写法相同，如float
    # 当被转换的msg不是纯数字会转换失败，报错 
    msg=int(x,y)
    # 将字符串x,按照y进制转换成10进制数
    eg:
    msg=int('abc',16) # 将字符串'abc'按照16进制数转换成10进制数

    # 转换原因
    不同的数据类型有时候不能进行运算

    # True False
    在进行数据运算时,True=1,False=0;
    eg:
    print(True + 1)  # 结果为2
  3. 转换成布尔值
    1
    2
    3
    4
    # 在数字里，只有0会被转换成False
    # 在字符串里只有空字符串会被转换成False,空格串也会被转换成True
    # None会被转换为False,eg:bool(None),打印出来是False
    # 空数据类型会被转换成False,如[],(),{}等

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 261 阅读时长 ≈ 1 分钟

  1. 在cmd中输入Python打开软件商店

        原因：在系统环境变量和用户环境变量的path中，当WindowsApps在python所配置的环境变量前的时候，就会先打开WindowsApps
        解决方法：1.在系统环境和用户环境变量的path中删掉WindowsApps这一项；2.在系统环境和用户环境变量的path中将WindowsApps这一项移动到python环境变量的下面，这样python环境变量就会先被执行，不会造成那样的意外

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 129 阅读时长 ≈ 1 分钟

Pycharm基本使用

  1. 双击shift键(或Ctrl+shift+A)，会弹出全局搜索窗口
  2. 快速格式化代码 Ctrl+shift+L
  3. 快速复制粘贴选中代码 Ctrl+D
  4. 移动一行代码 Ctrl+shift+上下箭头
  5. 光标定位到一行开头Fn+左箭头，定位到一行结尾Fn+右箭头

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 878 阅读时长 ≈ 1 分钟

Python基本语法

  1. 注释
    1
    2
    # 单行注释
    # ptint("Hello Python")  //用# 或ctrl+/
    1
    2
    3
    # 多行注释
    # print("你好")
    # print("您好") //先选中，然后用Ctrl+/
  2. 变量
    1
    2
    # 变量直接赋值
    msg="abc"
  3. input输入
    1
    2
    3
    msg=input("请输入")
    # msg为变量名
    # input括号里为输入提示信息
  4. del删除
    1
    2
    del(msg)
    # msg：删除的变量名
  5. 标识符规则
  • 由字母，数字，下划线组成
  • 开头不能是数字
  • 不能是Python关键字
  1. 数据类型
  • str(字符串)
  • Number(数字)
    • 整数
    • 浮点数
    • 复数msg=1+2j
  • bool(布尔值)
  • None(空值)
  • list(列表)
  • tuple(元组)
  • dict(字典)
  • set(集合)
    1
    2
    3
    #使用type获取数据类型
    msg=123
    print(type(a))
  1. 数据运算符的分类(与C语言一直的省略)
    1
    2
    3
    4
    # 求幂 **
    print(2**3) # 2的3次幂
    # 取整 //
    print(12//5) # 12对5取整
  2. 符合运算符(写法与C一致)
    1
    2
    3
    a=a+b
    等价于
    a+=b
  3. 关系运算符(与C一致)
    1
    == != > < >= <=
  4. 常用位运算符(将数字转化为二进制进行运算)
    1
    2
    3
    4
    5
    6
    & # 按位与
    | # 按位或
    ^ # 按位异或
    ~ # 按位取反
    << # 左移位
    >> # 右移位
  5. print
    1
    2
    3
    4
    5
    6
    print(a,b,c); 
    # 可以打印一个或多个变量或字符串
    print(value1,value2,value3,,sep=' ',end='\n')
    # sep值用来设定输出时多个值之间的连接符，默认是空格
    # end值用来设定输出结束时的结束符，默认是换行
    # sep,end两者都是以键值对的形式出现
  6. input
    1
    2
    3
    4
    msg=input("提示信息") 
    # input括号里保存的是提示信息
    # 输入的信息会保存在变量msg
    # 无论输入的是什么，msg的数据类型都为str

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 259 阅读时长 ≈ 1 分钟

  1. 注册域名
    可以挑选腾讯云或阿里云，或则其余任何一家进行域名注册

  2. 获取github仓库IP
    打开cmd,ping 仓库名.github.io,获取IP

    我的这个ping的有点问题，但方法没错

  3. 域名和IP绑定
    找到控制台，点解析

    然后点击修改，按照下面图片提示
  4. 创建CNAME文件
    在blog/source目录创建CNAME(无后缀名),把申请的域名填入即可
  5. 域名和github仓库绑定
    打开存放博客的仓库，点击settings,找到

    在输入框输入申请的域名，然后点击save
  6. 访问
    域名，IP，https://仓库名.github.io，三则都可访问