整型

  简介

# 是否可变类型: 不可变类型
# 作用:记录年龄、手机号
# 定义:
age = 18 # --> 内部操作 age = int(18)
# int('sada') # 报错
int(1.1)
# int('1.1') # int() 只能转纯数字的字符串,小数点都不行 a = 11111
print(id(a))
a = 122121
print(id(a))
#
#
# id变了,所以是不可变类型

    可变类型不可变类型

'''
可变类型: 值改变的情况下,id不变,说明你改的是原值
不可变类型:值改变的情况下,id一定变
'''

 进制转换

    十进制转其他进制

 # -------------- 十进制 --> 其他进制 -------------
# 》》》 十进制转二进制 《《《
print(bin(12)) # 0b1100 0b表示后面的数字是二进制数 # 》》》 十进制转八进制 《《《
print(oct(12)) # 0o14 0o表示后面的数字是八进制14 >>> 1*(8**1) + 4*(8**0) # 》》》 十进制转十六进制 《《《
print(hex(12)) # 0xC 0x表示后面的数字是十六进制数 # 0b1100
# 0o14
# 0xc

    其他进制转十进制

 # -------------- 其他进制 --> 十进制 -------------
# 》》》二进制转十进制《《《
10 # 1*(2**1) + 0*(2**0) 2
print(int('', 2))
# # 》》》八进制转十进制《《《
235 # 2*(8**2) + 3*(8**1) + 5*(8**0)
print(int('', 8))
# # 》》》十六进制转十进制 0-9 A-F《《《
217 # 2*(16**2) + 1*(16**1) + 7*(16**0)
print(int('c', 16))
#

浮点型

  简介

# 作用: 薪资、身高、体重
# 是否可变类型:不可变类型
res = float('1.11')
print(type(res))
# <class 'float'> print(id(res))
res = 1.2 # --> res = float(1.2)
print(id(res))
#
#

字符串

  简介

# 用途:存放描述性信息
# 虽然它可以用索引取值,但其本质上只有一个值
# 有序(有序: 但凡有索引的数据都是有序的)
# 是否可变类型:不可变类型 # 定义方式: '内容', "内容", '''内容''', """内容"""
# 之所以提供这么多定义方式(引号)是因为引号可能会用到
s = 'hello world' # s = str('hello world') s1 = str([1, 2, 3, 4]) # 等同于在其两边套上了引号
print(s1, type(s1))
# [1, 2, 3, 4] <class 'str'> s1 = str({'name': 'jason', 'age': 18})
print(s1, type(s1))
# {'name': 'jason', 'age': 18} <class 'str'>

      按索引取值

string = 'hello world.'
print(string[0])
# h
# string[0] = 'H' # 直接报错,str 字符串类型只能按索引取值,不能通过索引改

      len获取字符个数与in/not判断是否存在

# len  统计字符串中字符的个数
s = 'hello big baby~'
print(len(s))
# # 使用内置的方法统一采用 句点符(.) # in , not in 判断一个子字符串是否存在于一个大的字符串中
s = 'hello big baby~'
print('big' in s)
print('big' not in s)
print('bigger' in s)
print('bigger' not in s)
# True
# False
# False
# True

  切片操作

      详见列表类型中的切片部分推荐文章。

# 切片(顾头不顾尾,步长):从一个大的字符串中截取一段新的小字符串
s = 'hello big baby~'
print(s[0: 10])
print(s[0: 10: 2])
# hello big
# hlobg print(s[-1])
# -1 取最后一个字符 print(s[-2])
# -2 取倒数第二个字符
# 切片取值默认是从左往右的 print(s[5: 0: -1]) # 从5 开始 到0 (顾头不顾尾,顾5 不顾 0)
# olle print(s[-1: -10])
print(s[-1: -10: -1])
#
# ~ybab gib

      切片个人小总结

# 关于切片取值的新思路(切片是顾头不顾尾的)
string = '这不过只是一个切片的测试案例而已啦!'
# 想要反向截取部分,步长一定是负的 # 想要正常(顺序不变)截取字符串前面部分,步长一定是 正的, 起始值用索引正的(0是第一位,第几位到第几位)
# 前五个字符
print(string[0:5])
# 这不过只是 # 第六到第十三个字符
print(string[5:14])
# 一个切片的测试案例 # 想要正常(顺序不变)截取字符串后面部分,步长一定是 正的, 起始值用索引负的(-1倒数第一位, -2倒数第二位,依次类推)
# 最后四个字符(写-1 最后一个取不到。。。 如果终止值写0,就什么都取不到了,取值的方向就不对了)
# 终止值不写默认是到最后一个值
print(string[-4: ])
# 而已啦
print(string[-4: -1])
# 而已啦! # 反向截取的不常用,也就不举例了

  内置函数

      去除首尾指定字符(串) strip(), lstrip(), rstrip()

# strip() 默认去除字符串左右两端的指定字符(默认为空,去除左右两端空格)
name = 'jason'
name2 = ' jason '
print(name == name2, name.strip() == name2.strip())
# False True # 去除两端的指定字符
name = '$$$$egon$A$$$'
print(name.strip('$'))
# egon$A # 去除多字符也可以
name = '$%@ jason*&^('
print(name.strip('$%@ &('))
# jason*&^ # lstrip() 去除字符串左侧指定字符
name = '$$jason##$$'
print(name.lstrip('$')) # left 左
# jason##$$
# rstrip() 去除字符串右侧指定字符
print(name.rstrip('$')) # right 右
# $$jason##

      字符串切割 split(), rsplit()

# split 将字符串按照指定字符切割成列表,可指定切割次数
# split:针对按照某种分隔符组织的字符串,可以用split将其切分成 [列表] ,进而进行取值
# 切割顺序是从左往右的
data = 'jason|123|handsome'
name, age, description = data.split('|')
print(data.split('|'))
print(name, age, description)
# ['jason', '123', 'handsome']
# jason 123 handsome data = 'jason|123|handsome'
print(data.split('o', 1)) # 通过参数指定切割次数
print(data.split('o'))
print(data.rsplit('o'))
# ['jas', 'n|123|handsome']
# ['jas', 'n|123|hands', 'me']
# ['jas', 'n|123|hands', 'me']
# 如果不指定,rsplit() 和 split() 是一样的

      将字符串以指定字符(串)作为分隔拼接起来

# join 将列表以指定字符串作为分隔拼接起来
data = 'jason|123|handsome'
res_list = data.split('|')
res_str = ' '.join(res_list)
print(res_str)
# jason 123 handsome # l = [1, 'a', 'b']
# res = '|'.join(l) # ----》报错,join 方法只能用来拼接字符串,不能与其他类型拼接《----
# print(res)

      作为迭代器对象循环遍历  for 变量 in 字符串对象

# 在for 循环中遍历
data = 'jason|123|handsome beatiful'
for i in data:
print(i, end='--')
# j--a--s--o--n--|--1--2--3--|--h--a--n--d--s--o--m--e-- --b--e--a--t--i--f--u--l--
print()

      转换字符串的大小写(只影响字母) lower  upper  capitalize  swapcase  title

# lower upper 函数统一转换字符串的大小写
s = 'HAfaganGA'
print(s.lower())
print(s.upper())
print(s)
# hafaganga ————> 全转换成小写
# HAFAGANGA ————> 全转换成大写
# HAfaganGA ————> s 本身没有发生改变
# 调用方法并不改变字符串本身 # captallize swapcase titlle 大小写转换意义化
s = 'hElLo WoRLD10'
print(s.capitalize()) # 整个字符串首字母大写,其他都变小写(全大写文章转换成句子)
print(s.swapcase()) # 大小写交换
print(s.title()) # 单词之间首字母大写 (全大写单词转换成首字母大写的单词)
# Hello world10
# HeLlO wOrld10
# Hello World10

      判断字符串否与以指定字符开头/结尾 startwith  endwith

# startswith 判断字符串是否以...开头
# endswith 判断字符串是否以...结尾
s = 'jason dsb'
print(s.startswith('jas'))
print(s.endswith('sb'))
# True
# True

      字符串格式化 format

# format 字符串格式化 (python推荐使用format 做替换,做格式化输出)
# 三种玩法
# 1.按位置占位 --> 与 %s 原理一样
name = 'jason'
age = 18
str1 = 'my name is {} my age is {}'.format(name, age)
print(str1)
# my name is jason my age is 18 # 2.按索引占位 --> 支持一个变量多个位置调用
str1 = 'my name is {0} my age is {0}'.format("egon", 18)
print(str1)
# my name is egon my age is egon # {0} {0}都用的第一个参数 # 3.指名道姓(关键字传参)占位,同样支持一个(关键字)变量多个位置调用
name = 'jason'
age = 18
str1 = 'my name is {name} my age is {age} name = {name}'.format(name=name, age=age)
print(str1)
# my name is jason my age is 18 name = jason

      将字符串的指定字符(串)替换成新的指定字符(串),可以指定次数

# replace 替换指定字符(串)成新的指定字符(串),可指定次数
string = 'egon is dsb and egon is sb and egon has a BENZ'
res = string.replace('egon', 'kevin', 2)
print(res)
# kevin is dsb and kevin is sb and egon has a BENZ
# replace('要替换的旧字符串', '新的字符串', 替换个数)

      字符串是否是数字 isnumeric  isdecimal   isdigit

# is 数字系列
# isnumeric() 只要是数字都识别,不能识别二进制
# isdecimal() 只能识别普通的阿拉伯数字 0123456789
# isdigit() 数字都能识别(包括二进制) --> 通常情况下使用它就能满足需求了
# 在python3中
num1 = b'' # bytes
num2 = u'' # unicode,python3中无需加u就是unicode
num3 = '壹' # 中文数字
num4 = 'Ⅳ' # 罗马数字 # ''.isnumeric(): unicode,中文数字,罗马数字
# print(num1.isnumeric()) # 直接就会报错,num1 根本就没有isnumeric 这个方法
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
# True
# True
# True # ''.isdecimal(): unicode
# print(num1.isdecimal()) # 直接报错,num1 根本就没有isdecimal 这个方法
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
# True
# False
# False # ''.isdigit() :bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
# True
# True
# False
# False # isdigit() 字符串是否是数字, 直接 int() 非数字的字符串会直接报错
# 用来判断字符串是否是纯数字
age = input('>>>:')
if age.isdigit():
print(f"age = {age}")
else:
print("请好好输入")
# 后续代码待完善,用pass 顶一下,后续再写
pass # 在if、while、for中不知道写什么了,可以暂时用 pass 补全python代码块结构(搭框架,然后慢慢补充)不报错

     其他主了解部分

       查找指定元素的在字符串中的索引 find   rfind   index   rindex

# find index
s = '"kevin is dsb and kevin is sb"'
# find('dsb') # 返回的是d字符所在的索引值,找不到的时候不报错,返回的是 -1
# find('dsb', 0, 3) # 在 0 - 2(3, 顾头不顾尾) 的索引中查找字符(0, 3)限制查找范围
print(s.find('vin'))
print(s.rfind('vin'))
#
# # index('0') # 返回所传字符所在的索引值,找不到的时候会在直接报错
# find('dsb', 0, 3) # 在 0 - 2(3, 顾头不顾尾) 的索引中查找字符(0, 3)限制查找范围
print(s.index('vin'))
#
print(s.rindex('vin'))
#

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

# count
# 统计所传参数在字符串中出现了几次
s = '"kevin is dsb and kevin is sb"'
print(s.count('vin'))
#

       字符串格式化填充(对齐功能) center   ljust  rjust    zfill 可指定填充符

# 字符串格式化填充(对齐) center ljust  rjust  zfill
s = 'jason'
# center 把现在的字符串居中,其他的用指定字符在两遍填充,使其达到指定长度
print(s.center(40, '$')) # 不能左右平分的时候,右边会比左边多一个
print(s.ljust(40, '$'))
print(s.rjust(40, '$'))
print(s.rjust(40, ' ')) # 可以用在左对齐右对齐上
print(s.zfill(40)) # zfill z 表示zero 零
# $$$$$$$$$$$$$$$$$jason$$$$$$$$$$$$$$$$$$
# jason$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$jason
# 00000000000000000000000000000000000jason

       制表符扩展成指定个数 expandtabs

# expandtabs 扩展 tab的占位 成 指定个数的空格 (\t 制表符)
s = 'a\tbc'
s2 = 'abc'
print(s, '---', s2)
print(s.expandtabs(), '---', s2.expandtabs())
print(s.expandtabs(6))
# a bc --- abc
# a bc --- abc
# a bc

       转义字符知识扩展(Python中 '\r' 的实际应用  ——>该文章中利用 '\r' 实现了命令行中实现倒计时、转圈、百分比进度条的案例,厉害)

# \n 表示回车
string1 = '-a-\n-b-'
string2 = '-a-\r-b-'
print(string1)
print('--------------')
print(string2)
# -a-
# -b-
# --------------
# -b-
print() # \r 表示将光标的位置回退到本行的开头位置(将控制台当前行删除)
print('-----------------', end='')
print('-a-', end='')
print('\r', end='')
print('-b-', end='')
# -b- print()
# \b 表示将光标的位置回退一位(在控制台当前行最后删除一个字符)
print('-----------------***', end='')
print('\b\b|||')
# -----------------*|||

列表

  简介

# 作用:记录多组数据,如爱好、课程
# 是否可变类型: 可变类型,元素的值改变后,该变量的内存地址并不会发生改变
# 是否有序:有序,可通过索引取值
# 定义:list() 方法内部原理就是for 循环取值,然后一个个塞到列表中去
list_a = [1, 2, 3, 4] # list_a = list([1, 2, 3, 4])
list_a = list('[1, 2, 3, 4]')
print(list_a)
# ['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']'] list_a = list('1,2,3,4')
print(list_a)
# ['1', ',', '2', ',', '3', ',', '4'] list_a = list('')
print(list_a)
# ['1', '2', '3', '4']

  切片

      推荐一篇写得非常好的文章,其切片用列表举例(彻底搞懂Python切片操作

      列表对象[起点索引: 终点索引: 步长]

        起点索引代表开始位置的索引值(可以为负数,负几就是从右往左数第几)

        终点索引代表结束位置的索引值(可以为负数,负几就是从右往左数第几)

        步长正负代表方向,默认值为1代表从左往右

l = [1, 2, 3, 4]
print(l[0::])
# [1, 2, 3, 4] # 第二参数不写默认到 最后一个,第三个参数不写默认是1
print(l[5::-1])
# [4, 3, 2, 1] 

  添加元素 (.append()  .insert()   .extend())

# append
l = [1, 2, 3, 4]
l.append(5)
print(l) l = [1, 2, 3, 4]
l.append([5, 6, 7]) # 尾部添加元素,被添加的数据会被当做一个元素
print(l)
# [1, 2, 3, 4, [5, 6, 7]] # insert(索引, 要添加的元素) -->通过索引往指定位置(索引处)添加
l = [1, 2, 3, 4]
l.insert(3, 'hello')
print(l)
# [1, 2, 3, 'hello', 4] l = [1, 2, 3, 4]
l.insert(-1, [5, 6, 7]) # insert 意思是在某个索引前添加元素
# 被添加的数据会被当做一个元素
print(l)
# [1, 2, 3, [5, 6, 7], 4] l = [1, 2, 3, 4]
l.insert(len(l), [5, 6, 7]) # 利用insert特点在列表最后追加元素
print(l)
# [1, 2, 3, 4, [5, 6, 7]] # extend 将列表与另一个容器对象拼接
l = [1, 2, 3, 4]
l2 = ['hello', 'world']
l.extend(l2) # 将列表与另一个列表拼接,在后面追加 ---> 原理就是for循环一个个动态 append
# l.extend([1]) # 要用extand 添加单个元素,需要将其写成 容器类型(extend原理循环的对象必须是 容器类型)
# l.extend(1) # 会直接报错,因为 1 不是容器类型数据对象
print(l)
# [1, 2, 3, 4, 'hello', 'world'] l = [1, 2, 3, 4]
l2 = {'name': 'jason', 'age': 18}
l.extend(l2) # extend 字典对象,会将字典的key 作为元素添加与列表合并(list本质for循环,而字典在循环时暴露出来的是key )
print(l)
# [1, 2, 3, 4, 'name', 'age'] l = [1, 2, 3, 4]
l.extend('helloworld') # extend str字符串类型,会将字符串每一个字符都单独作为一个元素与列表合并(str可以被for 循环迭代遍历)
print(l)
# [1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'] 

  删除元素(del 对象, .pop(可选参数-->索引) .remove(参数-->元素对象))

      del 删除

# del 适用于所有的删除操作
l = [1, 2, 3, 4]
# print(del l[2]) # 会报错, del 没有返回值
del l[2]
print(l)
# [1, 2, 4] # 删除其他类型举例
s = 'cvnm'
# print(del s) # 会报错, del 没有返回值
# del s
# print(s) # 会报错,因为s 已经被删掉了,现在s 是未定义的

     pop 与 remove

# pop  弹出,尾部弹出   pop有返回值,会打印当前弹出对象的值 ---> 可以用在注销登录时,可以获取到用户的用户名
l = [1, 2, 3, 4]
print(l.pop())
print(l)
#
# [1, 2, 3] l = [1, 2, 3, 4]
print(l.pop(0)) # 可以指定弹出索引处的元素
print(l)
#
# [2, 3, 4] # remove
l = [1, 2, 3, 4]
print(l.remove(1)) # 删除了已存在的元素返回 None, 不存在的元素会直接报错(ValueError: list.remove(x): x not in list)
# print(l.remove(6)) # remove一个不存在的值,直接报错
# print(l.remove()) # 直接报错,remove 必须传入一个要删除的元素
print(l)
# None
# [1, 3, 4]

  模拟队列、堆栈操作

# 队列: 先进先出,后进后出
demo_list = ['first', 'second', 'third']
print(demo_list)
# ['first', 'second', 'third'] # 进队
demo_list.append('fourth')
print(demo_list)
# ['first', 'second', 'third', 'fourth'] # 出队
demo_list.pop(0) # 将第一个元素删除(第一个出列 --> 先进先出,后进后出)
print(demo_list)
# ['second', 'third', 'fourth'] # 堆栈: 先进后出,后进先出
demo_list = ['first', 'second', 'third']
print(demo_list)
# ['first', 'second', 'third'] # 进栈
demo_list.append('fourth')
print(demo_list)
# ['first', 'second', 'third', 'fourth'] # 出栈
# demo_list.pop() # 默认参数 -1
demo_list.pop(-1) # 将最后一个元素删除(最后一个出列 --> 先进后出,后进先出)
print(demo_list)
# ['first', 'second', 'third']

  列表与字符串互转

# ------------- 利用 str字符串的内置函数 split 与 join 完成 列表与字符串的互转 -----------
l = ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']
print(l)
# ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much'] connect = '-我是连接符-'
print(connect.join(l))
# hello-我是连接符-thank-我是连接符-you-我是连接符-thank-我是连接符-you-我是连接符-very-我是连接符-much
'''
# 使用字符串的 join 方法将列表转成字符串
# 调用 .join 方法的对象就是 列表元素连接的连接符
''' split_string = connect.join(l)
print(split_string)
print(split_string.split(connect))
# ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much'] print(split_string.split(connect) == l)
# True

  向python 列表尾部追加元素的几种方式(目前已知)

# 向python 列表尾部追加元素的几种方式(目前已知)
# 1.append
l = [1, 2, 3, 4]
l.append([5, 6, 7])
print(l)
# [1, 2, 3, 4, [5, 6, 7]] # 2.insert
l = [1, 2, 3, 4]
l.insert(len(l), [5, 6, 7]) # 利用insert 在列表最后追加元素
print(l)
# [1, 2, 3, 4, [5, 6, 7]] # 3.extend 可一次性追加多个元素
l = [1, 2, 3, 4]
l.extend([5, 6, 7])
print(l)
# [1, 2, 3, 4, 5, 6, 7]
# 追加单个元素
l = [1, 2, 3, 4]
l.extend([5]) # 这里不能写成 5, 会报错, 应该写成 容器对象(列表)
print(l)
# [1, 2, 3, 4, 5] # 4.切片 可一次性追加多个元素
l = [1, 2, 3, 4]
l[len(l): len(l)] = [5, 6, 7]
print(l)
# [1, 2, 3, 4, 5, 6, 7]
# 追加单个元素
l = [1, 2, 3, 4]
l[len(l): len(l)] = [5] # 这里不能直接写成 5, 会报错, 应该写成 容器对象(列表)
print(l)
# [1, 2, 3, 4, 5]

     追加元素知识点延伸(浅拷贝与深拷贝 ---> 推荐阅读  Python中的赋值、浅拷贝、深拷贝)(我的另一篇文章中做出了原理解释 python包-logging-hashlib-openpyxl模块-深浅拷贝-04) 

# 关于套用对象的补充(深拷贝浅拷贝)
l = [1, 2, 3, 4]
l2 = [5, 6, 7]
l.append(l2)
print(l, l2)
print(id(l), id(l2))
# [1, 2, 3, 4, [5, 6, 7]] [5, 6, 7]
# 1894310619272 1894311439560 l2[0] = 6 # 在l append l2 之后, 改变l2 的第一个元素
print(l, l2)
print(id(l), id(l2))
# [1, 2, 3, 4, [6, 6, 7]] [6, 6, 7]
# 1894310619272 1894311439560
# 比较结果发现 l2内部改变了 并且 l1的内部元素也发生了改变
# --> 所以这是浅拷贝,赋值完成后改变了l2的值 l1受到了影响 --> [1, 2, 3, 4, [6, 6, 7]] [6, 6, 7]
# 如果是深拷贝,赋值完成后改变l2 的值 l1 不会受到影响 --> [1, 2, 3, 4, [5, 6, 7]] [6, 6, 7]

ps:其他数据类型及函数后续补充

python整型-浮点型-字符串-列表及内置函数(上)的更多相关文章

  1. python字符串——"奇葩“的内置函数

      一.前言 python编程语言里的字符串与我们初期所学的c语言内的字符串还是有一定不同的,比如python字符串里的内置函数就比语言的要多得多:字符串内的书写格式也会有一点差异,例:字符串内含有引 ...

  2. Python成长之路第二篇(2)_列表元组内置函数用法

    列表元组内置函数用法list 元组的用法和列表相似就不一一介绍了 1)def append(self, p_object):将值添加到列表的最后 # real signature unknown; r ...

  3. 老男孩python学习自修第十一天【内置函数】

    1.基本内置函数 help() 帮助文档 dir() 列出当前文件的所有变量和方法 vars() 列出当前文件的所有变量及其值 type() 返回变量的类型 id() 返回变量的内存地址 len() ...

  4. python面向对象的基础语法(dir内置函数、self参数、初始化方法、内置方法和属性)

    面相对象基础语法 目标 dir 内置函数 定义简单的类(只包含方法) 方法中的 self 参数 初始化方法 内置方法和属性 01. dir 内置函数(知道) 在 Python 中 对象几乎是无所不在的 ...

  5. Python:数字类型和字符串类型的内置方法

    一.数字类型内置方法 1.1 整型的内置方法 作用 描述年龄.号码.id号 定义方式 x = 10 x = int('10') x = int(10.1) x = int('10.1') # 报错 内 ...

  6. Python开发【第五篇】内置函数

    abs() 函数返回数字的绝对值 __author__ = "Tang" a = -30 all() 函数用于判断给定的可迭代参数iterable中的所有元素是否都为True,如果 ...

  7. 记录我的 python 学习历程-Day12 生成器/推导式/内置函数Ⅰ

    一.生成器 初识生成器 生成器的本质就是迭代器,在python社区中,大多数时候都把迭代器和生成器是做同一个概念. 唯一的不同就是: 迭代器都是Python给你提供的已经写好的工具或者通过数据转化得来 ...

  8. Python自动化运维之5、内置函数

    python3.x内置函数 官网详解 一些例子:后期慢慢接触到再补充 # help() 详细查看某个类有那些方法或者方法的具体使用 >>> help(str) >>> ...

  9. 洗礼灵魂,修炼python(42)--巩固篇—type内置函数与类的千丝万缕关系

    type函数的隐藏属性 相信大家都知道内置函数type是用来查看对象的数据类型的.例: 那比如我对int类查看类型呢? 有朋友会说,int是内置类啊,用自定义的应该不会这样,我们自定义一个类呢? 还是 ...

随机推荐

  1. C++的类型转换:static_cast、dynamic_cast、reinterpret_cast和const_cast(dynamic_cast还支持交叉转换,const_cast将一个类的const、volatile以及__unaligned属性去掉)

    在C++中,存在类型转换,通常意味着存在缺陷(并非绝对).所以,对于类型转换,有如下几个原则:(1)尽量避免类型转换,包括隐式的类型转换(2)如果需要类型转换,尽量使用显式的类型转换,在编译期间转换( ...

  2. c# RedisHelper

    使用redis组件如下,至于为什么使用3.9版本,是因为4.0开始商业了,限制了次数 ServiceStack.Common" version="3.9.70"Servi ...

  3. 为什么说 2017 年你必须要学习 Go 了(多核,网络,多人协作,简单非OO,没有注解,Native,垃圾收集,代码优雅),附两个评论

    为什么要学习Go Go是未来的服务端语言— Tobias Lütke, Shopify.在过去的几年中,Golang逐步流行起来. 还有什么能比一门新语言让码农们疯狂呢? 因此,我开始学习了一段时间G ...

  4. pytorch实现yolov3(1) yolov3基本原理

    理解一个算法最好的就是实现它,对深度学习也一样,准备跟着https://blog.paperspace.com/how-to-implement-a-yolo-object-detector-in-p ...

  5. python 参考知识点

    本笔记仅作为有编程基础的童鞋在学习python时的参考资料,不适合零基础小白,并假设在你的电脑上已经正确安装了python环境,windows下需要配置环境变量,可以在终端窗口中执行以下命令 set ...

  6. lodop+art-template实现web端漂亮的小票样式打印

    一. 现状 由于之前采用Lodop打印控件(商业版付费,可以使用免费版 但是会有水印)去打印小票,是一行一行的打印,但是不满足UI给到复杂布局的小票样式,所以得重新考虑如何来实现. 二. 介绍 art ...

  7. Java多线程(三):Synchronized

    多线程安全 脏读:多个线程对同一个对象的实例变量进行修改后访问,导致读到的数据是被修改过的. 实例 ThreadDomain16类 public class ThreadDomain16 { priv ...

  8. Hadoop初步学习

    我们老板理解的大数据是,从数据到知识的转化.大数据目前的应用如 支付宝金融大数据.腾讯出行大数据等. 大数据的工作就是从海量数据源中筛选,梳理对自己有用的数据,整合成合适的数据结构,存储并进行可视化. ...

  9. JavaScript学习笔记(2)

    常用对象 Boolean Number String Array 数组 Date 日期 Math 数字 RegExp 正则 Global 全局 函数 var m = function(){} 事件 o ...

  10. php抽奖概率程序

    抽奖概率思想: 1.给每一个奖项设置要给概率数,如下面所有奖品综合设置为100,iphone5s是5,也就是5% 2.然后通过php生成随机数函数生成一个在总概率之间的随机数 如:抽第一个奖品5s的时 ...